diff --git a/dosgi/pom.xml b/dosgi/pom.xml
index b575be3bb..ecabe6f86 100644
--- a/dosgi/pom.xml
+++ b/dosgi/pom.xml
@@ -1,5 +1,5 @@
 <?xml version="1.0" encoding="UTF-8"?>
-<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+<project xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://maven.apache.org/POM/4.0.0" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
 
     <!--
 
diff --git a/dosgi/src/main/java/org/apache/karaf/cellar/dosgi/Constants.java b/dosgi/src/main/java/org/apache/karaf/cellar/dosgi/Constants.java
index c26b686ec..e7e3d85e1 100644
--- a/dosgi/src/main/java/org/apache/karaf/cellar/dosgi/Constants.java
+++ b/dosgi/src/main/java/org/apache/karaf/cellar/dosgi/Constants.java
@@ -18,9 +18,11 @@
  */
 public abstract class Constants {
 
+    public static final String DOT = ".";
     public static final String SEPARATOR = "/";
     public static final String ALL_INTERFACES = "*";
-    public static final String INTERFACE_SEPARATOR = ",";
+    public static final String COMMA_SEPARATOR = ",";
+    public static final String SERVICE_DOT = "service.";
     public static final String INTERFACE_PREFIX = "org.apache.karaf.cellar.dosgi";
     public static final String REQUEST_PREFIX = "org.apache.karaf.cellar.dosgi.request";
     public static final String RESULT_PREFIX = "org.apache.karaf.cellar.dosgi.result";
@@ -28,4 +30,4 @@ public abstract class Constants {
     public static final String EXPORTED_INTERFACES = "service.exported.interfaces";
     public static final String ENDPOINT_FRAMEWORK_UUID = "frameworkUUID";
 
-}
+}
\ No newline at end of file
diff --git a/dosgi/src/main/java/org/apache/karaf/cellar/dosgi/EndpointDescription.java b/dosgi/src/main/java/org/apache/karaf/cellar/dosgi/EndpointDescription.java
index 193b18264..e2fd3264c 100644
--- a/dosgi/src/main/java/org/apache/karaf/cellar/dosgi/EndpointDescription.java
+++ b/dosgi/src/main/java/org/apache/karaf/cellar/dosgi/EndpointDescription.java
@@ -32,41 +32,80 @@
 public class EndpointDescription implements MultiNode {
 
     private final String id;
-    private final Set<Node> nodes = new LinkedHashSet<Node>();
-    private final Map<String, Object> properties = new HashMap<String, Object>();
+    private final String filter;
+    private final Set<Node> nodes = new LinkedHashSet();
+    private final Map<String, Object> properties = new HashMap();
 
     /**
-     * Constructor
+     * Constructor with service properties
      *
      * @param id
      * @param node
+     * @param properties
      */
-    public EndpointDescription(String id, Node node) {
+    public EndpointDescription(String id, Node node, Map<String, Object> properties) {
         this.id = id;
         this.nodes.add(node);
-        properties.put(org.osgi.framework.Constants.OBJECTCLASS,getServiceClass());
+        this.properties.putAll(properties);
+        this.filter = createFilterString(properties, false);
     }
 
+    /**
+     * Constructor LDAP filter string from service properties
+     * with or without object class
+     *
+     * @param properties
+     * @param includeObjectClass
+     */
+    public static String createFilterString(Map<String, Object> properties, boolean includeObjectClass) {
+        if (properties.size() == 0) {
+            return null;
+        }
+        int filterCount = 0;
+        StringBuilder filterStringBuilder = new StringBuilder();
+        for (Map.Entry<String, Object> entry : properties.entrySet()) {
+            if (entry.getValue() instanceof String) {
+                switch (entry.getKey()) {
+                    case org.osgi.framework.Constants.OBJECTCLASS:
+                        if (includeObjectClass) {
+                            filterStringBuilder.append("(").append(entry.getKey()).append("=").append(entry.getValue()).append(")");
+                            filterCount++;
+                        }
+                        break;
+                    default:
+                        filterStringBuilder.append("(").append(entry.getKey()).append("=").append(entry.getValue()).append(")");
+                        filterCount++;
+                        break;
+                }
+            }
+        }
+        if (filterCount == 1) {
+            return filterStringBuilder.toString();
+        } else if (filterCount > 1) {
+            return filterStringBuilder.insert(0, "(&").append(')').toString();
+        } else {
+            return null;
+        }
+    }
 
     /**
      * Tests the properties of this <code>EndpointDescription</code> against
      * the given filter using a case insensitive match.
      *
-     * @param filter The filter to test.
+     * @param filterString The filter to test.
      * @return <code>true</code> If the properties of this
-     *         <code>EndpointDescription</code> match the filter,
-     *         <code>false</code> otherwise.
+     * <code>EndpointDescription</code> match the filter,
+     * <code>false</code> otherwise.
      * @throws IllegalArgumentException If <code>filter</code> contains an
      *                                  invalid filter string that cannot be parsed.
      */
-    public boolean matches(String filter) {
-        Filter f;
+    public boolean matches(String filterString) {
+        Filter filter;
         try {
-            f = FrameworkUtil.createFilter(filter);
+            filter = FrameworkUtil.createFilter(filterString);
         } catch (InvalidSyntaxException e) {
-            IllegalArgumentException iae = new IllegalArgumentException(e.getMessage());
-            iae.initCause(e);
-            throw iae;
+            IllegalArgumentException illegalArgumentException = new IllegalArgumentException(e.getMessage(), e);
+            throw illegalArgumentException;
         }
 
         Dictionary dictionary = new Properties();
@@ -76,42 +115,46 @@ public boolean matches(String filter) {
             dictionary.put(key, value);
         }
         /*
-           * we can use matchCase here since properties already supports case
-           * insensitive key lookup.
-           */
-        return f.matchCase(dictionary);
+         * we can use matchCase here since properties already supports case-insensitive key lookup.
+         */
+        return filter.matchCase(dictionary);
     }
 
     public String getId() {
         return id;
     }
 
+    public String getVersion() {
+        String result = null;
+        String[] parts = id.split(Constants.SEPARATOR);
+        if (parts != null && parts.length > 0) {
+            result = parts[parts.length - 1];
+        }
+        return result;
+    }
+
+    public String getFilter() {
+        return filter;
+    }
+
     public Set<Node> getNodes() {
         return nodes;
     }
 
-     public void setNodes(Set<Node> nodes) {
-         if(nodes != null) {
-             for(Node node:nodes) {
-                 this.nodes.add(node);
-             }
-         }
-     }
+    public void setNodes(Set<Node> nodes) {
+        if (nodes != null) {
+            for (Node node : nodes) {
+                this.nodes.add(node);
+            }
+        }
+    }
 
     public Map<String, Object> getProperties() {
         return properties;
     }
 
     public final String getServiceClass() {
-        String result = null;
-
-        if(id != null) {
-            String[] parts = id.split(Constants.SEPARATOR);
-            if(parts != null && parts.length > 0) {
-                result = parts[0];
-            }
-        }
-        return result;
+        return (String) properties.get(org.osgi.framework.Constants.OBJECTCLASS);
     }
 
     @Override
@@ -125,11 +168,7 @@ public boolean equals(Object o) {
 
         EndpointDescription endpointDescription = (EndpointDescription) o;
 
-        if (id != null ? !id.equals(endpointDescription.id) : endpointDescription.id != null) {
-            return false;
-        }
-
-        return true;
+        return id != null ? id.equals(endpointDescription.id) : endpointDescription.id == null;
     }
 
     @Override
@@ -137,4 +176,4 @@ public int hashCode() {
         return id != null ? id.hashCode() : 0;
     }
 
-}
+}
\ No newline at end of file
diff --git a/dosgi/src/main/java/org/apache/karaf/cellar/dosgi/ExportServiceListener.java b/dosgi/src/main/java/org/apache/karaf/cellar/dosgi/ExportServiceListener.java
index fff299b73..00a84ede6 100644
--- a/dosgi/src/main/java/org/apache/karaf/cellar/dosgi/ExportServiceListener.java
+++ b/dosgi/src/main/java/org/apache/karaf/cellar/dosgi/ExportServiceListener.java
@@ -30,22 +30,20 @@
 import java.util.LinkedHashSet;
 import java.util.Map;
 import java.util.Set;
+import java.util.TreeMap;
 
 /**
  * Listener called when a new service is exported.
  */
 public class ExportServiceListener implements ServiceListener {
 
-    private static final transient Logger LOGGER = LoggerFactory.getLogger(ExportServiceListener.class);
+    private static final Logger LOGGER = LoggerFactory.getLogger(ExportServiceListener.class);
 
-    private ClusterManager clusterManager;
+    private final Map<String, EventConsumer> consumers = new HashMap<>();
+    private Map<String, EndpointDescription> remoteEndpoints;
     private EventTransportFactory eventTransportFactory;
-
+    private ClusterManager clusterManager;
     private BundleContext bundleContext;
-    private Map<String, EndpointDescription> remoteEndpoints;
-
-    private final Map<String, EventConsumer> consumers = new HashMap<String, EventConsumer>();
-
     private Node node;
 
     public void init() {
@@ -54,7 +52,7 @@ public void init() {
         bundleContext.addServiceListener(this);
 
         // lookup for already exported services
-        ServiceReference[] references = null;
+        ServiceReference[] references;
         try {
             String filter = "(" + Constants.EXPORTED_INTERFACES + "=" + Constants.ALL_INTERFACES + ")";
             references = bundleContext.getServiceReferences((String) null, filter);
@@ -113,37 +111,45 @@ public void exportService(ServiceReference serviceReference) {
 
             String exportedServices = (String) serviceReference.getProperty(Constants.EXPORTED_INTERFACES);
             if (exportedServices != null && exportedServices.length() > 0) {
-                LOGGER.debug("CELLAR DOSGI: registering services {} in the cluster", exportedServices);
-                String[] interfaces = exportedServices.split(Constants.INTERFACE_SEPARATOR);
-                Object service = bundleContext.getService(serviceReference);
+                Map<String, Object> serviceProperties = getServiceProperties(serviceReference, false);
+
+                LOGGER.debug("CELLAR DOSGI: registering service(s) {} in the cluster with parameter(s) {}", exportedServices, serviceProperties);
 
+                String[] interfaces = exportedServices.split(Constants.COMMA_SEPARATOR);
+                Object service = bundleContext.getService(serviceReference);
                 Set<String> exportedInterfaces = getServiceInterfaces(service, interfaces);
 
-                for (String iface : exportedInterfaces) {
-                    // add endpoint description to the set.
-                    Version version = serviceReference.getBundle().getVersion();
-                    String endpointId = iface + Constants.SEPARATOR + version.toString();
+                for (String exportedInterface : exportedInterfaces) {
+                    if (!exportedInterface.trim().isEmpty()) {
+                        // add endpoint description to the set, the endpoint ID must contain all significant service identifiers
+                        String version = serviceReference.getBundle().getVersion().toString();
+                        String endpointId = exportedInterface + concatenateServiceProperties(serviceProperties) + version;
 
-                    EndpointDescription endpoint;
+                        EndpointDescription endpoint;
 
-                    if (remoteEndpoints.containsKey(endpointId)) {
-                        endpoint = remoteEndpoints.get(endpointId);
-                        endpoint.getNodes().add(node);
-                    } else {
-                        endpoint = new EndpointDescription(endpointId, node);
-                    }
+                        if (remoteEndpoints.containsKey(endpointId)) {
+                            LOGGER.debug("CELLAR DOSGI: adding endpoint ID to existing node {}", endpointId);
+                            endpoint = remoteEndpoints.get(endpointId);
+                            endpoint.getNodes().add(node);
+                        } else {
+                            LOGGER.debug("CELLAR DOSGI: creating new endpoint ID {}", endpointId);
+                            serviceProperties.put(org.osgi.framework.Constants.OBJECTCLASS, exportedInterface);
+                            endpoint = new EndpointDescription(endpointId, node, serviceProperties);
+                        }
 
-                    remoteEndpoints.put(endpointId, endpoint);
+                        remoteEndpoints.put(endpointId, endpoint);
 
-                    // register the endpoint consumer
-                    EventConsumer consumer = consumers.get(endpointId);
-                    if (consumer == null) {
-                        consumer = eventTransportFactory.getEventConsumer(Constants.INTERFACE_PREFIX + Constants.SEPARATOR + endpointId, false);
-                        consumers.put(endpointId, consumer);
-                    } else if (!consumer.isConsuming()) {
-                        consumer.start();
+                        // register the endpoint consumer
+                        EventConsumer consumer = consumers.get(endpointId);
+                        if (consumer == null) {
+                            consumer = eventTransportFactory.getEventConsumer(Constants.INTERFACE_PREFIX + Constants.SEPARATOR + endpointId, false);
+                            consumers.put(endpointId, consumer);
+                        } else if (!consumer.isConsuming()) {
+                            consumer.start();
+                        }
                     }
                 }
+                bundleContext.ungetService(serviceReference);
             }
         } finally {
             Thread.currentThread().setContextClassLoader(originalClassLoader);
@@ -161,27 +167,34 @@ public void unExportService(ServiceReference serviceReference) {
             Thread.currentThread().setContextClassLoader(getClass().getClassLoader());
             String exportedServices = (String) serviceReference.getProperty(Constants.EXPORTED_INTERFACES);
             if (exportedServices != null && exportedServices.length() > 0) {
-                LOGGER.debug("CELLAR DOSGI: un-register service {} from the cluster", exportedServices);
-                String[] interfaces = exportedServices.split(Constants.INTERFACE_SEPARATOR);
+
+                Map<String, Object> serviceProperties = getServiceProperties(serviceReference, false);
+
+                LOGGER.debug("CELLAR DOSGI: un-register service(s) {} from the cluster with parameter(s) {}", exportedServices, serviceProperties);
+
+                String[] interfaces = exportedServices.split(Constants.COMMA_SEPARATOR);
                 Object service = bundleContext.getService(serviceReference);
 
                 Set<String> exportedInterfaces = getServiceInterfaces(service, interfaces);
 
-                for (String iface : exportedInterfaces) {
-                    // add endpoint description to the set.
-                    Version version = serviceReference.getBundle().getVersion();
-                    String endpointId = iface + Constants.SEPARATOR + version.toString();
+                for (String exportedInterface : exportedInterfaces) {
+                    if (!exportedInterface.trim().isEmpty()) {
+                        // add endpoint description to the set.
+                        Version version = serviceReference.getBundle().getVersion();
+                        String endpointId = exportedInterface + concatenateServiceProperties(serviceProperties) + version.toString();
+
+                        EndpointDescription endpointDescription = remoteEndpoints.remove(endpointId);
+                        endpointDescription.getNodes().remove(node);
+                        // if the endpoint is used for export from other nodes too, then put it back.
+                        if (endpointDescription.getNodes().size() > 0) {
+                            remoteEndpoints.put(endpointId, endpointDescription);
+                        }
 
-                    EndpointDescription endpointDescription = remoteEndpoints.remove(endpointId);
-                    endpointDescription.getNodes().remove(node);
-                    // if the endpoint is used for export from other nodes too, then put it back.
-                    if (endpointDescription.getNodes().size() > 0) {
-                        remoteEndpoints.put(endpointId, endpointDescription);
+                        EventConsumer eventConsumer = consumers.remove(endpointId);
+                        eventConsumer.stop();
                     }
-
-                    EventConsumer eventConsumer = consumers.remove(endpointId);
-                    eventConsumer.stop();
                 }
+                bundleContext.ungetService(serviceReference);
             }
         } finally {
             Thread.currentThread().setContextClassLoader(originalClassLoader);
@@ -214,7 +227,6 @@ public Set<String> getServiceInterfaces(Object service, String[] services) {
                         } else {
                             classLoader = ClassLoader.getSystemClassLoader();
                         }
-
                         Class clazz = classLoader.loadClass(s);
                         String ifaceName = clazz.getCanonicalName();
                         interfaceList.add(ifaceName);
@@ -227,6 +239,30 @@ public Set<String> getServiceInterfaces(Object service, String[] services) {
         return interfaceList;
     }
 
+    private Map<String, Object> getServiceProperties(ServiceReference serviceReference, boolean includeObjectClass) {
+        // sorted map for reproducible endpointId results
+        TreeMap<String, Object> serviceProperties = new TreeMap();
+        for (String key : serviceReference.getPropertyKeys()) {
+            // skip service private and instance properties
+            if (!key.startsWith(Constants.DOT) && !key.contains(Constants.SERVICE_DOT)) {
+                serviceProperties.put(key, serviceReference.getProperty(key));
+            }
+        }
+        if (!includeObjectClass) {
+            serviceProperties.remove(org.osgi.framework.Constants.OBJECTCLASS);
+        }
+        return serviceProperties;
+    }
+
+    private String concatenateServiceProperties(Map<String, Object> serviceProperties) {
+        String sortedServiceProperties = Constants.SEPARATOR;
+        if (serviceProperties.isEmpty()) return sortedServiceProperties;
+        for (Map.Entry<String, Object> entry : serviceProperties.entrySet()) {
+            sortedServiceProperties = sortedServiceProperties + entry.getKey() + "=" + entry.getValue() + Constants.SEPARATOR;
+        }
+        return sortedServiceProperties;
+    }
+
     public ClusterManager getClusterManager() {
         return clusterManager;
     }
@@ -251,4 +287,4 @@ public void setBundleContext(BundleContext bundleContext) {
         this.bundleContext = bundleContext;
     }
 
-}
+}
\ No newline at end of file
diff --git a/dosgi/src/main/java/org/apache/karaf/cellar/dosgi/ImportServiceListener.java b/dosgi/src/main/java/org/apache/karaf/cellar/dosgi/ImportServiceListener.java
index c37da8900..ede181b33 100644
--- a/dosgi/src/main/java/org/apache/karaf/cellar/dosgi/ImportServiceListener.java
+++ b/dosgi/src/main/java/org/apache/karaf/cellar/dosgi/ImportServiceListener.java
@@ -14,21 +14,26 @@
 package org.apache.karaf.cellar.dosgi;
 
 import org.apache.karaf.cellar.core.ClusterManager;
+import org.apache.karaf.cellar.core.Producer;
 import org.apache.karaf.cellar.core.command.ClusteredExecutionContext;
 import org.apache.karaf.cellar.core.command.CommandStore;
 import org.apache.karaf.cellar.core.command.ExecutionContext;
 import org.apache.karaf.cellar.core.event.EventConsumer;
-import org.apache.karaf.cellar.core.event.EventProducer;
 import org.apache.karaf.cellar.core.event.EventTransportFactory;
 import org.osgi.framework.BundleContext;
+import org.osgi.framework.ServiceReference;
 import org.osgi.framework.ServiceRegistration;
 import org.osgi.framework.hooks.service.ListenerHook;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
 import java.util.Collection;
+import java.util.Collections;
 import java.util.HashMap;
+import java.util.HashSet;
 import java.util.Hashtable;
+import java.util.Iterator;
+import java.util.LinkedHashMap;
 import java.util.LinkedHashSet;
 import java.util.Map;
 import java.util.Set;
@@ -39,48 +44,42 @@
 /**
  * Listener for the service import.
  */
-public class ImportServiceListener implements ListenerHook, Runnable {
+public class ImportServiceListener implements ListenerHook {
 
-    private static final transient Logger LOGGER = LoggerFactory.getLogger(ImportServiceListener.class);
+    private static final Logger LOGGER = LoggerFactory.getLogger(ImportServiceListener.class);
 
-    private BundleContext bundleContext;
+    private final ScheduledExecutorService scheduledExecutorService = Executors.newSingleThreadScheduledExecutor();
+    private final Map<ListenerInfo, String> listenerRegistrations = Collections.synchronizedMap(new LinkedHashMap());
+    private final Set<ListenerInfo> pendingListeners = Collections.synchronizedSet(new LinkedHashSet());
+    private final Map<String, ServiceRegistration> serviceRegistrations = new HashMap();
+    private final Map<String, ExecutionContext> executionContexts = new HashMap();
+    private final Map<String, EventConsumer> consumers = new HashMap();
+    private Map<String, EndpointDescription> remoteEndpoints;
+    private EventTransportFactory eventTransportFactory;
     private ClusterManager clusterManager;
+    private BundleContext bundleContext;
     private CommandStore commandStore;
-    private EventTransportFactory eventTransportFactory;
-    private Map<String, EndpointDescription> remoteEndpoints;
-
-    private Set<ListenerInfo> pendingListeners = new LinkedHashSet<ListenerInfo>();
-
-    private final Map<EndpointDescription, ServiceRegistration> registrations = new HashMap<EndpointDescription, ServiceRegistration>();
-
-    private final Map<String, EventProducer> producers = new HashMap<String, EventProducer>();
-    private final Map<String, EventConsumer> consumers = new HashMap<String, EventConsumer>();
-
-    private final ScheduledExecutorService service = Executors.newSingleThreadScheduledExecutor();
 
     public void init() {
         remoteEndpoints = clusterManager.getMap(Constants.REMOTE_ENDPOINTS);
-        service.scheduleAtFixedRate(this, 0, 5, TimeUnit.SECONDS);
+        scheduledExecutorService.scheduleWithFixedDelay(new RemoteServiceTracker(this), 5, 5, TimeUnit.SECONDS);
     }
 
     public void destroy() {
-        service.shutdown();
-        for (Map.Entry<EndpointDescription, ServiceRegistration> entry : registrations.entrySet()) {
-            ServiceRegistration registration = entry.getValue();
-            registration.unregister();
-        }
-        for (Map.Entry<String, EventConsumer> consumerEntry : consumers.entrySet()) {
-            EventConsumer consumer = consumerEntry.getValue();
-            consumer.stop();
-        }
-        consumers.clear();
-        producers.clear();
-    }
-
-    @Override
-    public void run() {
-        for (ListenerInfo listener : pendingListeners) {
-            checkListener(listener);
+        scheduledExecutorService.shutdown();
+        synchronized (pendingListeners) {
+            for (ServiceRegistration serviceRegistration : serviceRegistrations.values()) {
+                LOGGER.trace("CELLAR DOSGI: DESTROY removing registration {}", serviceRegistration.getReference().getPropertyKeys());
+                serviceRegistration.unregister();
+            }
+            for (EventConsumer eventConsumer : consumers.values()) {
+                eventConsumer.stop();
+            }
+            listenerRegistrations.clear();
+            serviceRegistrations.clear();
+            executionContexts.clear();
+            pendingListeners.clear();
+            consumers.clear();
         }
     }
 
@@ -89,15 +88,25 @@ public void added(Collection listeners) {
         ClassLoader originalClassLoader = Thread.currentThread().getContextClassLoader();
         try {
             Thread.currentThread().setContextClassLoader(getClass().getClassLoader());
+            // create a clone of remote endpoint descriptions to avoid concurrency concerns while iterating it
+            final Set<EndpointDescription> endpointDescriptions = new HashSet(remoteEndpoints.values());
             for (ListenerInfo listenerInfo : (Collection<ListenerInfo>) listeners) {
-
-                if (listenerInfo.getBundleContext() == bundleContext || listenerInfo.getFilter() == null) {
-                    continue;
+                if (listenerInfo.getFilter() == null) {
+                    LOGGER.trace("CELLAR DOSGI: skip adding listener with no filter for bundle {}", listenerInfo.getBundleContext().getBundle().getBundleId());
+                } else if (listenerInfo.getBundleContext() == bundleContext) {
+                    LOGGER.trace("CELLAR DOSGI: skip adding listener {} with same bundle context for bundle {}", listenerInfo.getFilter(), listenerInfo.getBundleContext().getBundle().getBundleId());
+                } else if (listenerInfo.isRemoved()) {
+                    // could be removed by bundles restarting
+                    LOGGER.trace("CELLAR DOSGI: skip adding already removed listener {} for bundle {}", listenerInfo.getFilter(), listenerInfo.getBundleContext().getBundle().getBundleId());
+                } else {
+                    // make sure we only import remote services
+                    if (!checkListener(listenerInfo, endpointDescriptions)) {
+                        LOGGER.trace("CELLAR DOSGI: adding pending listener {} for bundle {}", listenerInfo.getFilter(), listenerInfo.getBundleContext().getBundle().getBundleId());
+                        if (!pendingListeners.add(listenerInfo)) {
+                            LOGGER.warn("CELLAR DOSGI: pending listener {} for bundle {} already added!", listenerInfo.getFilter(), listenerInfo.getBundleContext().getBundle().getBundleId());
+                        }
+                    }
                 }
-
-                pendingListeners.add(listenerInfo);
-                // make sure we only import remote services
-                checkListener(listenerInfo);
             }
         } finally {
             Thread.currentThread().setContextClassLoader(originalClassLoader);
@@ -109,27 +118,44 @@ public void removed(Collection listeners) {
         ClassLoader originalClassLoader = Thread.currentThread().getContextClassLoader();
         try {
             Thread.currentThread().setContextClassLoader(getClass().getClassLoader());
+            // create a clone of remote endpoint descriptions to avoid concurrency concerns while iterating it
+            final Set<EndpointDescription> endpointDescriptions = new HashSet(remoteEndpoints.values());
             for (ListenerInfo listenerInfo : (Collection<ListenerInfo>) listeners) {
-                if (listenerInfo.getBundleContext() == bundleContext || listenerInfo.getFilter() == null) {
-                    continue;
-                }
-
-                // make sure we only import remote services
-                String filter = "(&" + listenerInfo.getFilter() + "(!(" + Constants.ENDPOINT_FRAMEWORK_UUID + "=" + clusterManager.getNode().getId() + ")))";
-                // iterate through known services and import them if needed
-                Set<EndpointDescription> matches = new LinkedHashSet<EndpointDescription>();
-                for (Map.Entry<String, EndpointDescription> entry : remoteEndpoints.entrySet()) {
-                    EndpointDescription endpointDescription = entry.getValue();
-                    if (endpointDescription.matches(filter)) {
-                        matches.add(endpointDescription);
+                if (listenerInfo.getFilter() == null) {
+                    LOGGER.trace("CELLAR DOSGI: skip removing listener with no filter for bundle {}", listenerInfo.getBundleContext().getBundle().getBundleId());
+                } else if (listenerInfo.getBundleContext() == bundleContext) {
+                    LOGGER.trace("CELLAR DOSGI: skip removing listener {} with same bundle context for bundle {}", listenerInfo.getFilter(), listenerInfo.getBundleContext().getBundle().getBundleId());
+                } else if (!listenerRegistrations.containsKey(listenerInfo)) {
+                    LOGGER.trace("CELLAR DOSGI: skip removing unregistered listener {} for bundle {}", listenerInfo.getFilter(), listenerInfo.getBundleContext().getBundle().getBundleId());
+                } else {
+                    // make sure we only match remote services for this listener
+                    String filter = "(&" + listenerInfo.getFilter() + "(!(" + Constants.ENDPOINT_FRAMEWORK_UUID + "=" + clusterManager.getNode().getId() + ")))";
+                    // iterate through known services and un-import them if needed
+                    Set<EndpointDescription> filteredEndpointEndpointDescriptions = new LinkedHashSet();
+                    for (EndpointDescription endpointDescription : endpointDescriptions) {
+                        if (endpointDescription.matches(filter)) {
+                            filteredEndpointEndpointDescriptions.add(endpointDescription);
+                        }
                     }
+                    synchronized (listenerRegistrations) {
+                        for (EndpointDescription filteredEndpointEndpointDescription : filteredEndpointEndpointDescriptions) {
+                            Iterator<Map.Entry<ListenerInfo, String>> iterator = listenerRegistrations.entrySet().iterator();
+                            while (iterator.hasNext()) {
+                                Map.Entry<ListenerInfo, String> entry = iterator.next();
+                                if (entry.getKey().equals(listenerInfo) && entry.getValue().equals(filteredEndpointEndpointDescription.getId())) {
+                                    LOGGER.trace("CELLAR DOSGI: removing registered listener {} for bundle {}", listenerInfo.getFilter(), listenerInfo.getBundleContext().getBundle().getBundleId());
+                                    iterator.remove();
+                                }
+                            }
+                            // un-import service from registry if last listener for this filter is removed
+                            if (!listenerRegistrations.containsValue(filteredEndpointEndpointDescription.getId())) {
+                                unImportService(filteredEndpointEndpointDescription.getId());
+                            }
+                        }
+                    }
+                    LOGGER.trace("CELLAR DOSGI: removing pending listener {} for bundle {}", listenerInfo.getFilter(), listenerInfo.getBundleContext().getBundle().getBundleId());
+                    pendingListeners.remove(listenerInfo);
                 }
-
-                for (EndpointDescription endpoint : matches) {
-                    unImportService(endpoint);
-                }
-
-                pendingListeners.remove(listenerInfo);
             }
         } finally {
             Thread.currentThread().setContextClassLoader(originalClassLoader);
@@ -137,80 +163,92 @@ public void removed(Collection listeners) {
     }
 
     /**
-     * Check if there is a match for the current {@link ListenerInfo}.
+     * Check if there is a match for the current {@link ListenerInfo} for importing if not already available.
      *
-     * @param listenerInfo the listener info.
+     * @param listenerInfo         the listener info.
+     * @param endpointDescriptions local copy of remote endpoint descriptions.
      */
-    private void checkListener(ListenerInfo listenerInfo) {
+    private boolean checkListener(ListenerInfo listenerInfo, Set<EndpointDescription> endpointDescriptions) {
         ClassLoader originalClassLoader = Thread.currentThread().getContextClassLoader();
         try {
             Thread.currentThread().setContextClassLoader(getClass().getClassLoader());
             // iterate through known services and import them if needed
-            Set<EndpointDescription> matches = new LinkedHashSet<EndpointDescription>();
-            for (Map.Entry<String, EndpointDescription> entry : remoteEndpoints.entrySet()) {
-                EndpointDescription endpointDescription = entry.getValue();
+            Set<EndpointDescription> matchedEndpointDescriptions = new LinkedHashSet();
+            for (EndpointDescription endpointDescription : endpointDescriptions) {
+                // match endpoint on OSGi filter and if not this node is already registered and if service is not already local
                 if (endpointDescription.matches(listenerInfo.getFilter()) && !endpointDescription.getNodes().contains(clusterManager.getNode().getId())) {
-                    matches.add(endpointDescription);
+                    ServiceReference[] serviceReferences = bundleContext.getServiceReferences(endpointDescription.getServiceClass(), listenerInfo.getFilter());
+                    if (serviceReferences == null) {
+                        matchedEndpointDescriptions.add(endpointDescription);
+                        LOGGER.trace("CELLAR DOSGI: remote endpoint {} available for local listener {}", endpointDescription.getId(), listenerInfo.getFilter());
+                    }
                 }
             }
-
-            for (EndpointDescription endpoint : matches) {
-                importService(endpoint, listenerInfo);
+            for (EndpointDescription matchedRemoteEndpointDescription : matchedEndpointDescriptions) {
+                importService(matchedRemoteEndpointDescription, listenerInfo);
             }
+            return matchedEndpointDescriptions.size() > 0;
+        } catch (Exception e) {
+            LOGGER.error("CELLAR DOSGI: listener {} check failed due to {}", listenerInfo.getFilter(), e.getMessage());
         } finally {
             Thread.currentThread().setContextClassLoader(originalClassLoader);
         }
+        return false;
     }
 
     /**
      * Import a remote service to the service registry.
      *
-     * @param endpoint the endpoint to import.
-     * @param listenerInfo the associated listener info.
+     * @param endpointDescription the endpoint to import.
+     * @param listenerInfo        the associated listener info.
      */
-    private void importService(EndpointDescription endpoint, ListenerInfo listenerInfo) {
-        LOGGER.debug("CELLAR DOSGI: importing remote service");
-
-        EventProducer requestProducer = producers.get(endpoint.getId());
-        if (requestProducer == null) {
-            requestProducer = eventTransportFactory.getEventProducer(Constants.INTERFACE_PREFIX + Constants.SEPARATOR + endpoint.getId(), Boolean.FALSE);
-            producers.put(endpoint.getId(), requestProducer);
+    private void importService(EndpointDescription endpointDescription, ListenerInfo listenerInfo) {
+        LOGGER.debug("CELLAR DOSGI: importing remote endpoint {} with filter {}", endpointDescription.getId(), listenerInfo.getFilter());
+
+        ExecutionContext executionContext = executionContexts.get(endpointDescription.getId());
+        if (executionContext == null) {
+            LOGGER.trace("CELLAR DOSGI: creating new request producer");
+            Producer requestProducer = eventTransportFactory.getEventProducer(Constants.INTERFACE_PREFIX + Constants.SEPARATOR + endpointDescription.getId(), Boolean.FALSE);
+            executionContext = new ClusteredExecutionContext(requestProducer, commandStore);
+            executionContexts.put(endpointDescription.getId(), executionContext);
         }
 
-        EventConsumer resultConsumer = consumers.get(endpoint.getId());
+        EventConsumer resultConsumer = consumers.get(endpointDescription.getId());
         if (resultConsumer == null) {
-            resultConsumer = eventTransportFactory.getEventConsumer(Constants.RESULT_PREFIX + Constants.SEPARATOR + clusterManager.getNode().getId() + endpoint.getId(), Boolean.FALSE);
-            consumers.put(endpoint.getId(), resultConsumer);
+            LOGGER.trace("CELLAR DOSGI: creating new result consumer");
+            resultConsumer = eventTransportFactory.getEventConsumer(Constants.RESULT_PREFIX + Constants.SEPARATOR + clusterManager.getNode().getId() + endpointDescription.getId(), Boolean.FALSE);
+            consumers.put(endpointDescription.getId(), resultConsumer);
         } else if (!resultConsumer.isConsuming()) {
             resultConsumer.start();
         }
 
-        producers.put(endpoint.getId(), requestProducer);
-        consumers.put(endpoint.getId(), resultConsumer);
-
-        ExecutionContext executionContext = new ClusteredExecutionContext(requestProducer, commandStore);
-
-        RemoteServiceFactory remoteServiceFactory = new RemoteServiceFactory(endpoint, clusterManager, executionContext);
-        ServiceRegistration registration = listenerInfo.getBundleContext().registerService(endpoint.getServiceClass(),
-                remoteServiceFactory,
-                new Hashtable<String, Object>(endpoint.getProperties()));
-        registrations.put(endpoint, registration);
-        pendingListeners.remove(listenerInfo);
+        LOGGER.trace("CELLAR DOSGI: adding service registration for {}", endpointDescription.getServiceClass());
+        RemoteServiceFactory remoteServiceFactory = new RemoteServiceFactory(clusterManager, executionContext, endpointDescription);
+        ServiceRegistration serviceRegistration = listenerInfo.getBundleContext().registerService(endpointDescription.getServiceClass(), remoteServiceFactory, new Hashtable(endpointDescription.getProperties()));
+        serviceRegistrations.put(endpointDescription.getId(), serviceRegistration);
+        listenerRegistrations.put(listenerInfo, endpointDescription.getId());
     }
 
     /**
      * Un-register an imported service.
      *
-     * @param endpoint the endpoint to un-register.
+     * @param endpointId the endpoint to un-register.
      */
-    private void unImportService(EndpointDescription endpoint) {
-        ServiceRegistration registration = registrations.get(endpoint);
-        registration.unregister();
-
-        producers.remove(endpoint.getId());
-        EventConsumer consumer = consumers.remove(endpoint.getId());
-        if (consumer != null) {
-            consumer.stop();
+    private void unImportService(String endpointId) {
+        ClassLoader originalClassLoader = Thread.currentThread().getContextClassLoader();
+        try {
+            Thread.currentThread().setContextClassLoader(getClass().getClassLoader());
+            LOGGER.debug("CELLAR DOSGI: un-importing remote service with endpoint {}", endpointId);
+
+            ServiceRegistration registration = serviceRegistrations.remove(endpointId);
+            if (registration != null) registration.unregister();
+
+            EventConsumer consumer = consumers.get(endpointId);
+            if (consumer != null) {
+                consumer.stop();
+            }
+        } finally {
+            Thread.currentThread().setContextClassLoader(originalClassLoader);
         }
     }
 
@@ -246,4 +284,54 @@ public void setEventTransportFactory(EventTransportFactory eventTransportFactory
         this.eventTransportFactory = eventTransportFactory;
     }
 
-}
+    private static class RemoteServiceTracker implements Runnable {
+
+        private static final Logger LOGGER = LoggerFactory.getLogger(RemoteServiceTracker.class);
+
+        private final ImportServiceListener importServiceListener;
+
+        public RemoteServiceTracker(ImportServiceListener importServiceListener) {
+            this.importServiceListener = importServiceListener;
+        }
+
+        @Override
+        public void run() {
+            try {
+                // create a clone of remote endpoints to avoid concurrency concerns while iterating it
+                final Set<Map.Entry<String, EndpointDescription>> threadLocalRemoteEndpointEntries = new HashSet(importServiceListener.remoteEndpoints.entrySet());
+                final Set<EndpointDescription> threadLocalRemoteEndpointValues = new HashSet(threadLocalRemoteEndpointEntries.size());
+                final Set<String> threadLocalRemoteEndpointKeys = new HashSet(threadLocalRemoteEndpointEntries.size());
+                for (Map.Entry<String, EndpointDescription> localRemoteEndpointEntry : threadLocalRemoteEndpointEntries) {
+                    threadLocalRemoteEndpointValues.add(localRemoteEndpointEntry.getValue());
+                    threadLocalRemoteEndpointKeys.add(localRemoteEndpointEntry.getKey());
+                }
+                LOGGER.trace("CELLAR DOSGI: running the remote service tracker task having {} endpoint(s), {} pending listener(s), {} registered listener(s) and {} service registration(s)",
+                        threadLocalRemoteEndpointEntries.size(), importServiceListener.pendingListeners.size(), importServiceListener.listenerRegistrations.size(), importServiceListener.serviceRegistrations.size());
+                synchronized (importServiceListener.pendingListeners) {
+                    Iterator<ListenerInfo> iterator = importServiceListener.pendingListeners.iterator();
+                    while (iterator.hasNext()) {
+                        ListenerInfo listenerInfo = iterator.next();
+                        if (importServiceListener.checkListener(listenerInfo, threadLocalRemoteEndpointValues)) {
+                            iterator.remove();
+                        }
+                    }
+                }
+                synchronized (importServiceListener.listenerRegistrations) {
+                    Iterator<Map.Entry<ListenerInfo, String>> listenerRegistrationIterator = importServiceListener.listenerRegistrations.entrySet().iterator();
+                    while (listenerRegistrationIterator.hasNext()) {
+                        Map.Entry<ListenerInfo, String> listenerRegistration = listenerRegistrationIterator.next();
+                        if (!threadLocalRemoteEndpointKeys.contains(listenerRegistration.getValue())) {
+                            LOGGER.trace("CELLAR DOSGI: registered remote endpoint {} unavailable", listenerRegistration.getValue());
+                            importServiceListener.unImportService(listenerRegistration.getValue());
+                            listenerRegistrationIterator.remove();
+                            importServiceListener.pendingListeners.add(listenerRegistration.getKey());
+                        }
+                    }
+                }
+            } catch (Exception e) {
+                LOGGER.error("CELLAR DOSGI: {} / {}", e.getClass().getSimpleName(), e.getMessage());
+            }
+        }
+    }
+
+}
\ No newline at end of file
diff --git a/dosgi/src/main/java/org/apache/karaf/cellar/dosgi/RemoteServiceCall.java b/dosgi/src/main/java/org/apache/karaf/cellar/dosgi/RemoteServiceCall.java
index 7ffcba447..f89d76b44 100644
--- a/dosgi/src/main/java/org/apache/karaf/cellar/dosgi/RemoteServiceCall.java
+++ b/dosgi/src/main/java/org/apache/karaf/cellar/dosgi/RemoteServiceCall.java
@@ -23,7 +23,9 @@
 public class RemoteServiceCall extends Command<RemoteServiceResult> {
 
     private String endpointId;
+    private String filter;
     private String method;
+    private String version;
     private String serviceClass;
     private List<Object> arguments;
 
@@ -31,12 +33,20 @@ public RemoteServiceCall(String id) {
         super(id);
     }
 
-    public List<Object> getArguments() {
-        return arguments;
+    public String getEndpointId() {
+        return endpointId;
     }
 
-    public void setArguments(List<Object> arguments) {
-        this.arguments = arguments;
+    public void setEndpointId(String endpointId) {
+        this.endpointId = endpointId;
+    }
+
+    public String getFilter() {
+        return filter;
+    }
+
+    public void setFilter(String filter) {
+        this.filter = filter;
     }
 
     public String getMethod() {
@@ -47,6 +57,14 @@ public void setMethod(String method) {
         this.method = method;
     }
 
+    public String getVersion() {
+        return version;
+    }
+
+    public void setVersion(String version) {
+        this.version = version;
+    }
+
     public String getServiceClass() {
         return serviceClass;
     }
@@ -55,12 +73,12 @@ public void setServiceClass(String serviceClass) {
         this.serviceClass = serviceClass;
     }
 
-    public String getEndpointId() {
-        return endpointId;
+    public List<Object> getArguments() {
+        return arguments;
     }
 
-    public void setEndpointId(String endpointId) {
-        this.endpointId = endpointId;
+    public void setArguments(List<Object> arguments) {
+        this.arguments = arguments;
     }
 
-}
+}
\ No newline at end of file
diff --git a/dosgi/src/main/java/org/apache/karaf/cellar/dosgi/RemoteServiceCallHandler.java b/dosgi/src/main/java/org/apache/karaf/cellar/dosgi/RemoteServiceCallHandler.java
index 810d4f4e7..868a66488 100644
--- a/dosgi/src/main/java/org/apache/karaf/cellar/dosgi/RemoteServiceCallHandler.java
+++ b/dosgi/src/main/java/org/apache/karaf/cellar/dosgi/RemoteServiceCallHandler.java
@@ -26,6 +26,8 @@
 import org.osgi.framework.BundleContext;
 import org.osgi.framework.InvalidSyntaxException;
 import org.osgi.framework.ServiceReference;
+import org.osgi.framework.Version;
+import org.osgi.framework.VersionRange;
 import org.osgi.service.cm.Configuration;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
@@ -41,7 +43,7 @@ public class RemoteServiceCallHandler extends CellarSupport implements EventHand
 
     public static final String SWITCH_ID = "org.apache.karaf.cellar.dosgi.switch";
 
-    private static final transient Logger LOGGER = LoggerFactory.getLogger(RemoteServiceCallHandler.class);
+    private static final Logger LOGGER = LoggerFactory.getLogger(RemoteServiceCallHandler.class);
 
     private final Switch dosgiSwitch = new BasicSwitch(SWITCH_ID);
 
@@ -52,10 +54,10 @@ public class RemoteServiceCallHandler extends CellarSupport implements EventHand
     /**
      * Handle a cluster remote service call event.
      *
-     * @param event the cluster event to handle.
+     * @param remoteServiceCall the cluster event to handle.
      */
     @Override
-    public void handle(RemoteServiceCall event) {
+    public void handle(RemoteServiceCall remoteServiceCall) {
 
         // check if the handler switch is ON
         if (this.getSwitch().getStatus().equals(SwitchStatus.OFF)) {
@@ -63,15 +65,33 @@ public void handle(RemoteServiceCall event) {
             return;
         }
 
+        long dosgiBundleId = bundleContext.getBundle().getBundleId();
+
         Object targetService = null;
 
-        if (event != null) {
-            ServiceReference[] serviceReferences = null;
+        if (remoteServiceCall != null) {
+            ServiceReference[] serviceReferences;
             try {
-                serviceReferences = bundleContext.getServiceReferences(event.getServiceClass(), null);
-                if (serviceReferences != null && serviceReferences.length > 0) {
-                    targetService = bundleContext.getService(serviceReferences[0]);
-                    bundleContext.ungetService(serviceReferences[0]);
+                // get all service references and versions for this class and filter
+                serviceReferences = bundleContext.getAllServiceReferences(remoteServiceCall.getServiceClass(), remoteServiceCall.getFilter());
+                LOGGER.trace("CELLAR DOSGI: handling remote call for service class {}", remoteServiceCall.getServiceClass());
+                if (serviceReferences != null) {
+                    Version versionMin = remoteServiceCall.getVersion() == null ? Version.emptyVersion : new Version(remoteServiceCall.getVersion());
+                    Version versionMax = new Version(versionMin.getMajor() + 1, 0, 0);
+                    VersionRange versionRange = new VersionRange(VersionRange.LEFT_CLOSED, versionMin, versionMax, VersionRange.RIGHT_OPEN);
+                    for (ServiceReference serviceReference : serviceReferences) {
+                        // avoid remote DOSGi registered services
+                        if (serviceReference.getBundle().getBundleId() != dosgiBundleId) {
+                            // match version range
+                            if (versionRange.includes(serviceReference.getBundle().getVersion())) {
+                                LOGGER.trace("CELLAR DOSGI: found local provider {} for service class {} for version {} and filter {}",
+                                        serviceReference.getBundle().getBundleId(), remoteServiceCall.getServiceClass(), versionRange, remoteServiceCall.getFilter());
+                                targetService = bundleContext.getService(serviceReference);
+                                bundleContext.ungetService(serviceReference);
+                                break;
+                            }
+                        }
+                    }
                 }
             } catch (InvalidSyntaxException e) {
                 LOGGER.error("CELLAR DOSGI: failed to lookup service", e);
@@ -79,19 +99,19 @@ public void handle(RemoteServiceCall event) {
 
             if (targetService != null) {
                 Class[] classes = new Class[0];
-                if (event.getArguments() != null && event.getArguments().size() > 0) {
-                    classes = new Class[event.getArguments().size()];
+                if (remoteServiceCall.getArguments() != null && remoteServiceCall.getArguments().size() > 0) {
+                    classes = new Class[remoteServiceCall.getArguments().size()];
                     int i = 0;
-                    for (Object obj : event.getArguments()) {
+                    for (Object obj : remoteServiceCall.getArguments()) {
                         classes[i++] = obj.getClass();
                     }
                 }
 
-                RemoteServiceResult result = new RemoteServiceResult(event.getId());
-                EventProducer producer = eventTransportFactory.getEventProducer(Constants.RESULT_PREFIX + Constants.SEPARATOR + event.getSourceNode().getId() + event.getEndpointId(), false);
+                RemoteServiceResult result = new RemoteServiceResult(remoteServiceCall.getId());
+                EventProducer producer = eventTransportFactory.getEventProducer(Constants.RESULT_PREFIX + Constants.SEPARATOR + remoteServiceCall.getSourceNode().getId() + remoteServiceCall.getEndpointId(), false);
                 try {
-                    Method method = getMethod(classes, targetService, event);
-                    Object obj = method.invoke(targetService, event.getArguments().toArray());
+                    Method method = getMethod(classes, targetService, remoteServiceCall);
+                    Object obj = method.invoke(targetService, remoteServiceCall.getArguments().toArray());
                     result.setResult(obj);
                     producer.produce(result);
 
@@ -118,17 +138,17 @@ public void handle(RemoteServiceCall event) {
      *
      * @param eventParamTypes
      * @param targetService
-     * @param event
+     * @param remoteServiceCall
      * @return a method instance from the <code>Object targetService<code/>
      * @throws NoSuchMethodException
      */
-    private Method getMethod(Class[] eventParamTypes, Object targetService, RemoteServiceCall event) throws NoSuchMethodException {
+    private Method getMethod(Class[] eventParamTypes, Object targetService, RemoteServiceCall remoteServiceCall) throws NoSuchMethodException {
 
         Method result = null;
         if (eventParamTypes.length > 0) {
             for (Method remoteMethod : targetService.getClass().getMethods()) {
                 //need to find a method with a matching name and with the same number of parameters
-                if (remoteMethod.getName().equals(event.getMethod()) && remoteMethod.getParameterTypes().length == eventParamTypes.length) {
+                if (remoteMethod.getName().equals(remoteServiceCall.getMethod()) && remoteMethod.getParameterTypes().length == eventParamTypes.length) {
                     boolean allParamsFound = true;
                     for (int i = 0; i < remoteMethod.getParameterTypes().length; i++) {
                         allParamsFound = allParamsFound && ClassUtils.isAssignable(eventParamTypes[i], remoteMethod.getParameterTypes()[i]);
@@ -142,12 +162,12 @@ private Method getMethod(Class[] eventParamTypes, Object targetService, RemoteSe
                 }
             }
         } else {
-            result = targetService.getClass().getMethod(event.getMethod());
+            result = targetService.getClass().getMethod(remoteServiceCall.getMethod());
         }
 
         //if method was not found go out with a bang
         if (result == null) {
-            throw new NoSuchMethodException(String.format("No match for method [%s] %s", event.getMethod(), Arrays.toString(eventParamTypes)));
+            throw new NoSuchMethodException(String.format("No match for method [%s] %s", remoteServiceCall.getMethod(), Arrays.toString(eventParamTypes)));
         }
 
         return result;
diff --git a/dosgi/src/main/java/org/apache/karaf/cellar/dosgi/RemoteServiceFactory.java b/dosgi/src/main/java/org/apache/karaf/cellar/dosgi/RemoteServiceFactory.java
index 11d132149..0f0846a9e 100644
--- a/dosgi/src/main/java/org/apache/karaf/cellar/dosgi/RemoteServiceFactory.java
+++ b/dosgi/src/main/java/org/apache/karaf/cellar/dosgi/RemoteServiceFactory.java
@@ -18,6 +18,8 @@
 import org.osgi.framework.Bundle;
 import org.osgi.framework.ServiceFactory;
 import org.osgi.framework.ServiceRegistration;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 
 import java.lang.reflect.Proxy;
 import java.util.ArrayList;
@@ -28,27 +30,33 @@
  */
 public class RemoteServiceFactory implements ServiceFactory {
 
-    private EndpointDescription description;
-    private ClusterManager clusterManager;
-    private ExecutionContext executionContext;
+    private static final Logger LOGGER = LoggerFactory.getLogger(RemoteServiceFactory.class);
 
-    public RemoteServiceFactory(EndpointDescription description, ClusterManager clusterManager, ExecutionContext executionContext) {
-        this.description = description;
+    private final ClusterManager clusterManager;
+    private final ExecutionContext executionContext;
+    private final EndpointDescription endpointDescription;
+
+    public RemoteServiceFactory(ClusterManager clusterManager, ExecutionContext executionContext, EndpointDescription endpointDescription) {
         this.clusterManager = clusterManager;
         this.executionContext = executionContext;
+        this.endpointDescription = endpointDescription;
     }
 
     @Override
     public Object getService(Bundle bundle, ServiceRegistration registration) {
         ClassLoader classLoader = new RemoteServiceProxyClassLoader(bundle);
-        List<Class> interfaces = new ArrayList<Class>();
-        String interfaceName = description.getServiceClass();
-            try {
-                interfaces.add(classLoader.loadClass(interfaceName));
-            } catch (ClassNotFoundException e) {
-                // Ignore
-            }
-        RemoteServiceInvocationHandler handler = new RemoteServiceInvocationHandler(description.getId(), interfaceName,clusterManager,executionContext);
+        List<Class> interfaces = new ArrayList();
+        String endpointId = endpointDescription.getId();
+        String filter = endpointDescription.getFilter();
+        String version = endpointDescription.getVersion();
+        String serviceClass = endpointDescription.getServiceClass();
+        try {
+            interfaces.add(classLoader.loadClass(serviceClass));
+        } catch (ClassNotFoundException e) {
+            // Ignore
+        }
+        LOGGER.trace("CELLAR DOSGI: Creating remote service invocation handler for service {} with filter {} having endpoint Id", serviceClass, filter, endpointId);
+        RemoteServiceInvocationHandler handler = new RemoteServiceInvocationHandler(endpointId, filter, version, serviceClass, clusterManager, executionContext);
         return Proxy.newProxyInstance(classLoader, interfaces.toArray(new Class[interfaces.size()]), handler);
     }
 
diff --git a/dosgi/src/main/java/org/apache/karaf/cellar/dosgi/RemoteServiceInvocationHandler.java b/dosgi/src/main/java/org/apache/karaf/cellar/dosgi/RemoteServiceInvocationHandler.java
index 79099f837..03c050b14 100644
--- a/dosgi/src/main/java/org/apache/karaf/cellar/dosgi/RemoteServiceInvocationHandler.java
+++ b/dosgi/src/main/java/org/apache/karaf/cellar/dosgi/RemoteServiceInvocationHandler.java
@@ -23,43 +23,50 @@
 import java.util.LinkedList;
 import java.util.List;
 import java.util.Map;
+import java.util.concurrent.CancellationException;
 
 /**
  * Handler for cluster remote service invocation event.
  */
 public class RemoteServiceInvocationHandler implements InvocationHandler {
 
-    private String endpointId;
-    private String serviceClass;
-    private ClusterManager clusterManager;
-    private ExecutionContext executionContext;
+    private final String endpointId;
+    private final String filter;
+    private final String version;
+    private final String serviceClass;
+    private final ClusterManager clusterManager;
+    private final ExecutionContext executionContext;
 
-    public RemoteServiceInvocationHandler(String endpointId,String serviceClass, ClusterManager clusterManager, ExecutionContext executionContext) {
+    public RemoteServiceInvocationHandler(String endpointId, String filter, String version, String serviceClass, ClusterManager clusterManager, ExecutionContext executionContext) {
         this.endpointId = endpointId;
+        this.filter = filter;
+        this.version = version;
         this.serviceClass = serviceClass;
         this.clusterManager = clusterManager;
         this.executionContext = executionContext;
     }
 
     @Override
-    public Object invoke(Object o, Method method, Object[] arguments) throws Throwable {
+    public Object invoke(Object object, Method method, Object[] arguments) throws Throwable {
         RemoteServiceCall remoteServiceCall = new RemoteServiceCall(clusterManager.generateId());
         remoteServiceCall.setEndpointId(endpointId);
+        remoteServiceCall.setFilter(filter);
         remoteServiceCall.setMethod(method.getName());
+        remoteServiceCall.setVersion(version);
         remoteServiceCall.setServiceClass(serviceClass);
         List argumentList = new LinkedList();
 
-        if(arguments != null && arguments.length > 0) {
-            for(Object arg:arguments) {
+        if (arguments != null && arguments.length > 0) {
+            for (Object arg : arguments) {
                 argumentList.add(arg);
             }
         }
 
         remoteServiceCall.setArguments(argumentList);
-        Map<Node,RemoteServiceResult> results =  executionContext.execute(remoteServiceCall);
+        Map<Node, RemoteServiceResult> results = executionContext.execute(remoteServiceCall);
 
-        if(results != null) {
-            for(Map.Entry<Node,RemoteServiceResult> entry:results.entrySet()) {
+        if (results != null) {
+            for (Map.Entry<Node, RemoteServiceResult> entry : results.entrySet()) {
                 RemoteServiceResult result = entry.getValue();
 
                 // an exception being thrown by the remote service call must be raised locally
@@ -75,7 +82,7 @@ public Object invoke(Object o, Method method, Object[] arguments) throws Throwab
                 return result.getResult();
             }
         }
-        return null;
+        throw new CancellationException(String.format("No remote service execution results for service %s with endpoint Id %s", serviceClass, endpointId));
     }
 
-}
+}
\ No newline at end of file
diff --git a/dosgi/src/main/java/org/apache/karaf/cellar/dosgi/RemoteServiceProxyClassLoader.java b/dosgi/src/main/java/org/apache/karaf/cellar/dosgi/RemoteServiceProxyClassLoader.java
index 4c5e430d6..fa8565de0 100644
--- a/dosgi/src/main/java/org/apache/karaf/cellar/dosgi/RemoteServiceProxyClassLoader.java
+++ b/dosgi/src/main/java/org/apache/karaf/cellar/dosgi/RemoteServiceProxyClassLoader.java
@@ -20,7 +20,7 @@
  */
 public class RemoteServiceProxyClassLoader extends ClassLoader {
 
-    private Bundle bundle;
+    private final Bundle bundle;
 
     public RemoteServiceProxyClassLoader(Bundle bundle) {
         this.bundle = bundle;
diff --git a/dosgi/src/main/java/org/apache/karaf/cellar/dosgi/internal/osgi/Activator.java b/dosgi/src/main/java/org/apache/karaf/cellar/dosgi/internal/osgi/Activator.java
index ae0e8d1f4..36944594a 100644
--- a/dosgi/src/main/java/org/apache/karaf/cellar/dosgi/internal/osgi/Activator.java
+++ b/dosgi/src/main/java/org/apache/karaf/cellar/dosgi/internal/osgi/Activator.java
@@ -17,7 +17,10 @@
 import org.apache.karaf.cellar.core.command.CommandStore;
 import org.apache.karaf.cellar.core.event.EventHandler;
 import org.apache.karaf.cellar.core.event.EventTransportFactory;
-import org.apache.karaf.cellar.dosgi.*;
+import org.apache.karaf.cellar.dosgi.ExportServiceListener;
+import org.apache.karaf.cellar.dosgi.ImportServiceListener;
+import org.apache.karaf.cellar.dosgi.RemoteServiceCallHandler;
+import org.apache.karaf.cellar.dosgi.RemoteServiceResultHandler;
 import org.apache.karaf.cellar.dosgi.management.ServiceMBean;
 import org.apache.karaf.cellar.dosgi.management.internal.ServiceMBeanImpl;
 import org.apache.karaf.util.tracker.BaseActivator;
diff --git a/dosgi/src/main/java/org/apache/karaf/cellar/dosgi/internal/osgi/RemovedNodeServiceTracker.java b/dosgi/src/main/java/org/apache/karaf/cellar/dosgi/internal/osgi/RemovedNodeServiceTracker.java
index 1bad57afc..995e461db 100644
--- a/dosgi/src/main/java/org/apache/karaf/cellar/dosgi/internal/osgi/RemovedNodeServiceTracker.java
+++ b/dosgi/src/main/java/org/apache/karaf/cellar/dosgi/internal/osgi/RemovedNodeServiceTracker.java
@@ -32,15 +32,13 @@
  */
 public class RemovedNodeServiceTracker implements Runnable {
 
-    private static final transient Logger LOGGER = LoggerFactory.getLogger(RemovedNodeServiceTracker.class);
-
+    private static final Logger LOGGER = LoggerFactory.getLogger(RemovedNodeServiceTracker.class);
+    private final ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(1);
     private ClusterManager clusterManager;
-
     private Map<String, EndpointDescription> remoteEndpoints;
 
-    private ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(1);
-
     public void init() {
+        // Creates or returns a Hazelcast distributed map instance with the specified name
         remoteEndpoints = clusterManager.getMap(Constants.REMOTE_ENDPOINTS);
         scheduler.scheduleWithFixedDelay(this, 10, 10, TimeUnit.SECONDS);
     }
@@ -60,11 +58,11 @@ public void setClusterManager(ClusterManager clusterManager) {
 
     @Override
     public void run() {
-        LOGGER.trace("CELLAR DOSGI: running the service tracker task");
+        LOGGER.trace("CELLAR DOSGI: running the remote node tracker task");
         ClassLoader originalClassLoader = Thread.currentThread().getContextClassLoader();
         try {
             if (!remoteEndpoints.isEmpty()) {
-                LOGGER.trace("CELLAR DOSGI: found {} remote endpoints", remoteEndpoints.size());
+                LOGGER.trace("CELLAR DOSGI: found {} remote endpoint(s)", remoteEndpoints.size());
                 Thread.currentThread().setContextClassLoader(getClass().getClassLoader());
                 final Set<Node> activeNodes = clusterManager.listNodes();
 
@@ -108,4 +106,4 @@ public void run() {
         }
     }
 
-}
+}
\ No newline at end of file
diff --git a/dosgi/src/main/java/org/apache/karaf/cellar/dosgi/management/ServiceMBean.java b/dosgi/src/main/java/org/apache/karaf/cellar/dosgi/management/ServiceMBean.java
index eb4bc5f12..07540788e 100644
--- a/dosgi/src/main/java/org/apache/karaf/cellar/dosgi/management/ServiceMBean.java
+++ b/dosgi/src/main/java/org/apache/karaf/cellar/dosgi/management/ServiceMBean.java
@@ -21,6 +21,6 @@
  */
 public interface ServiceMBean {
 
-    public Map<String, List<String>> getServices();
+    Map<String, List<String>> getServices();
 
 }
diff --git a/dosgi/src/main/java/org/apache/karaf/cellar/dosgi/management/internal/ServiceMBeanImpl.java b/dosgi/src/main/java/org/apache/karaf/cellar/dosgi/management/internal/ServiceMBeanImpl.java
index a5272f448..707d8ab5a 100644
--- a/dosgi/src/main/java/org/apache/karaf/cellar/dosgi/management/internal/ServiceMBeanImpl.java
+++ b/dosgi/src/main/java/org/apache/karaf/cellar/dosgi/management/internal/ServiceMBeanImpl.java
@@ -21,7 +21,11 @@
 
 import javax.management.NotCompliantMBeanException;
 import javax.management.StandardMBean;
-import java.util.*;
+import java.util.HashMap;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
 
 public class ServiceMBeanImpl extends StandardMBean implements ServiceMBean {
 
diff --git a/dosgi/src/main/java/org/apache/karaf/cellar/dosgi/shell/ListDistributedServicesCommand.java b/dosgi/src/main/java/org/apache/karaf/cellar/dosgi/shell/ListDistributedServicesCommand.java
index 67fb074ad..39d30908b 100644
--- a/dosgi/src/main/java/org/apache/karaf/cellar/dosgi/shell/ListDistributedServicesCommand.java
+++ b/dosgi/src/main/java/org/apache/karaf/cellar/dosgi/shell/ListDistributedServicesCommand.java
@@ -20,7 +20,14 @@
 import org.apache.karaf.shell.api.action.Command;
 import org.apache.karaf.shell.api.action.lifecycle.Service;
 import org.apache.karaf.shell.support.table.ShellTable;
+import org.osgi.framework.Bundle;
+import org.osgi.framework.BundleContext;
+import org.osgi.framework.FrameworkUtil;
+import org.osgi.framework.ServiceReference;
 
+import java.util.Arrays;
+import java.util.Comparator;
+import java.util.HashSet;
 import java.util.Map;
 import java.util.Set;
 
@@ -33,27 +40,95 @@ protected Object doExecute() throws Exception {
         ClassLoader originalClassLoader = Thread.currentThread().getContextClassLoader();
         try {
             Thread.currentThread().setContextClassLoader(getClass().getClassLoader());
+            Node localNode = clusterManager.getNode();
             Map<String, EndpointDescription> remoteEndpoints = clusterManager.getMap(Constants.REMOTE_ENDPOINTS);
+
             if (remoteEndpoints != null && !remoteEndpoints.isEmpty()) {
                 ShellTable table = new ShellTable();
                 table.column("Service Class");
-                table.column("Provider Node");
-                for (Map.Entry<String, EndpointDescription> entry : remoteEndpoints.entrySet()) {
+                table.column("Version");
+                table.column("Consumer");
+                table.column("Provider");
+                table.column("Node");
+                table.column(" ");
+                table.column("Filter");
+                BundleContext bundleContext = FrameworkUtil.getBundle(ListDistributedServicesCommand.class).getBundleContext();
+                long dosgiBundleId = bundleContext.getBundle().getBundleId();
+                Map.Entry<String, EndpointDescription>[] entrySet = remoteEndpoints.entrySet().toArray(new Map.Entry[remoteEndpoints.size()]);
+                Arrays.sort(entrySet, new Comparator<Map.Entry<String, EndpointDescription>>() {
+                    @Override
+                    public int compare(Map.Entry<String, EndpointDescription> a, Map.Entry<String, EndpointDescription> b) {
+                        return a.getKey().compareTo(b.getKey());
+                    }
+                });
+                for (Map.Entry<String, EndpointDescription> entry : entrySet) {
                     EndpointDescription endpointDescription = entry.getValue();
+                    String version = endpointDescription.getVersion();
+                    String filter = endpointDescription.getFilter();
                     String serviceClass = endpointDescription.getServiceClass();
-                    Set<Node> nodes = endpointDescription.getNodes();
+                    ServiceReference[] serviceReferences = bundleContext.getServiceReferences(serviceClass, filter);
+
+                    Node[] nodes = endpointDescription.getNodes().toArray(new Node[endpointDescription.getNodes().size()]);
+                    Arrays.sort(nodes, new Comparator<Node>() {
+                        @Override
+                        public int compare(Node a, Node b) {
+                            return (a.getHost() + a.getPort()).compareTo(b.getHost() + b.getPort());
+                        }
+                    });
+
+                    Set<Long> consumerBundleIds = new HashSet();
+                    boolean hasNodeProvider = false;
+                    boolean hasRemoteProvider = false;
+
                     for (Node node : nodes) {
-                        String nodeName = node.getAlias();
-                        if (nodeName == null) {
-                            nodeName = node.getId();
+                        String providerNode = node.getAlias();
+                        if (providerNode == null) {
+                            providerNode = node.getId();
+                        }
+                        Set<Long> providerBundleIds = new HashSet();
+                        if (node.equals(localNode)) {
+                            if (serviceReferences != null) {
+                                for (ServiceReference serviceReference : serviceReferences) {
+                                    providerBundleIds.add(serviceReference.getBundle().getBundleId());
+                                    hasNodeProvider = true;
+                                    Bundle[] bundles = serviceReference.getUsingBundles();
+                                    if (bundles != null) {
+                                        for (Bundle bundle : bundles) {
+                                            consumerBundleIds.add(bundle.getBundleId());
+                                        }
+                                    }
+                                }
+                            }
+                            String consumerBundleIdsString = consumerBundleIds.toString().replaceAll("^\\[|]$", "");
+                            String providerBundleIdsString = providerBundleIds.toString().replaceAll("^\\[|]$", "");
+                            table.addRow().addContent(serviceClass, version, consumerBundleIdsString, providerBundleIdsString, providerNode, "x", filter);
+                        } else {
+                            if (serviceReferences != null) {
+                                for (ServiceReference serviceReference : serviceReferences) {
+                                    providerBundleIds.add(dosgiBundleId);
+                                    hasRemoteProvider = true;
+                                    Bundle[] bundles = serviceReference.getUsingBundles();
+                                    if (bundles != null) {
+                                        for (Bundle bundle : bundles) {
+                                            if (hasNodeProvider && hasRemoteProvider) {
+                                                consumerBundleIds.remove(bundle.getBundleId());
+                                            } else {
+                                                consumerBundleIds.add(bundle.getBundleId());
+                                            }
+                                        }
+                                    }
+                                }
+                                consumerBundleIds.remove(dosgiBundleId);
+                            }
+                            String consumerBundleIdsString = consumerBundleIds.toString().replaceAll("^\\[|]$", "");
+                            String providerBundleIdsString = providerBundleIds.toString().replaceAll("^\\[|]$", "");
+                            table.addRow().addContent(serviceClass, version, consumerBundleIdsString, providerBundleIdsString, providerNode, "", filter);
                         }
-                        table.addRow().addContent(serviceClass, nodeName);
-                        serviceClass = "";
                     }
                 }
                 table.print(System.out);
             } else {
-                System.out.println("No service available on the cluster");
+                System.out.println("No remote service available on the cluster");
             }
         } finally {
             Thread.currentThread().setContextClassLoader(originalClassLoader);
@@ -61,4 +136,4 @@ protected Object doExecute() throws Exception {
         return null;
     }
 
-}
+}
\ No newline at end of file
diff --git a/dosgi/src/test/java/org/apache/karaf/cellar/dosgi/EndpointDescriptionTest.java b/dosgi/src/test/java/org/apache/karaf/cellar/dosgi/EndpointDescriptionTest.java
index c13f52dca..829b3dd74 100644
--- a/dosgi/src/test/java/org/apache/karaf/cellar/dosgi/EndpointDescriptionTest.java
+++ b/dosgi/src/test/java/org/apache/karaf/cellar/dosgi/EndpointDescriptionTest.java
@@ -16,6 +16,9 @@
 import org.junit.Assert;
 import org.junit.Test;
 
+import java.util.HashMap;
+import java.util.Map;
+
 public class EndpointDescriptionTest {
 
     String objectClass = "org.apache.karaf.cellar.dosgi.Test";
@@ -24,13 +27,40 @@ public class EndpointDescriptionTest {
     @Test
     public void testMatches() throws Exception {
         // this is a dummy test for testing the behaviour of matches method
+        String version = "1.0.0";
         String testEndpointFilter = String.format(filterPattern, objectClass);
-        String endpointId = objectClass + Constants.SEPARATOR + "1.0.0";
+        String endpointId = objectClass + Constants.SEPARATOR + version;
+        HashMap<String, Object> exportedProperties = new HashMap<String, Object>();
+        exportedProperties.put(org.osgi.framework.Constants.OBJECTCLASS, objectClass);
 
-        EndpointDescription endpointDescription1 = new EndpointDescription(endpointId, null);
-        EndpointDescription endpointDescription2 = new EndpointDescription(endpointId, null);
+        EndpointDescription endpointDescription1 = new EndpointDescription(endpointId, null, exportedProperties);
+        EndpointDescription endpointDescription2 = new EndpointDescription(endpointId, null, exportedProperties);
         Assert.assertTrue(endpointDescription1.matches(testEndpointFilter));
         Assert.assertTrue(endpointDescription2.matches(testEndpointFilter));
     }
 
-}
+    @Test
+    public void testFilterStringCreation() {
+        Map<String, Object> properties = new HashMap();
+        properties.put(org.osgi.framework.Constants.OBJECTCLASS, "SomeServiceClass");
+        String result = EndpointDescription.createFilterString(properties, false);
+        Assert.assertNull(result);
+        EndpointDescription endpointDescription = new EndpointDescription("id", null, properties);
+        Assert.assertNull(endpointDescription.getFilter());
+        result = EndpointDescription.createFilterString(properties, true);
+        Assert.assertTrue(result.equals("(objectClass=SomeServiceClass)"));
+        properties.put("someServiceKey", "SomeServiceValue");
+        result = EndpointDescription.createFilterString(properties, false);
+        Assert.assertTrue(result.equals("(someServiceKey=SomeServiceValue)"));
+        result = EndpointDescription.createFilterString(properties, true);
+        Assert.assertTrue(result.equals("(&(objectClass=SomeServiceClass)(someServiceKey=SomeServiceValue))"));
+        properties.put("someServiceObject", new Object());
+        result = EndpointDescription.createFilterString(properties, false);
+        Assert.assertTrue(result.equals("(someServiceKey=SomeServiceValue)"));
+        result = EndpointDescription.createFilterString(properties, true);
+        Assert.assertTrue(result.equals("(&(objectClass=SomeServiceClass)(someServiceKey=SomeServiceValue))"));
+        endpointDescription = new EndpointDescription("id", null, properties);
+        Assert.assertTrue(endpointDescription.getFilter().equals("(someServiceKey=SomeServiceValue)"));
+    }
+
+}
\ No newline at end of file
diff --git a/dosgi/src/test/java/org/apache/karaf/cellar/dosgi/ExportServiceListenerTest.java b/dosgi/src/test/java/org/apache/karaf/cellar/dosgi/ExportServiceListenerTest.java
index 41849b0ab..77b22e5e8 100644
--- a/dosgi/src/test/java/org/apache/karaf/cellar/dosgi/ExportServiceListenerTest.java
+++ b/dosgi/src/test/java/org/apache/karaf/cellar/dosgi/ExportServiceListenerTest.java
@@ -28,18 +28,18 @@ public class ExportServiceListenerTest {
     public void testGetServiceInterfaces() throws Exception {
         System.out.println("Test Service interfaces with null service");
         Set<String> expectedResult = new LinkedHashSet<String>();
-        Set<String> result = listener.getServiceInterfaces(null,null);
-        Assert.assertEquals(expectedResult,result);
+        Set<String> result = listener.getServiceInterfaces(null, null);
+        Assert.assertEquals(expectedResult, result);
 
-        result = listener.getServiceInterfaces(null,new String[] {"*"});
-        Assert.assertEquals(expectedResult,result);
+        result = listener.getServiceInterfaces(null, new String[]{"*"});
+        Assert.assertEquals(expectedResult, result);
 
         System.out.println("Test Service interfaces with ArrayList and wildcard services");
-        result = listener.getServiceInterfaces(new ArrayList(),new String[] {"*"});
+        result = listener.getServiceInterfaces(new ArrayList(), new String[]{"*"});
         Assert.assertTrue(result.contains("java.util.List"));
 
         System.out.println("Test Service interfaces with ArrayList and List/Serializable services");
-        result = listener.getServiceInterfaces(new ArrayList(),new String[] {"java.util.List","java.io.Serializable"});
+        result = listener.getServiceInterfaces(new ArrayList(), new String[]{"java.util.List", "java.io.Serializable"});
         Assert.assertTrue(result.contains("java.util.List"));
         Assert.assertTrue(result.contains("java.io.Serializable"));
     }