MasterRegistrationManagerImpl.java

Go to the documentation of this file.

/*
 * Copyright (C) 2012 Google Inc.
 * 
 * Licensed under the Apache License, Version 2.0 (the "License"); you may not
 * use this file except in compliance with the License. You may obtain a copy of
 * the License at
 * 
 * http://www.apache.org/licenses/LICENSE-2.0
 * 
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
 * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
 * License for the specific language governing permissions and limitations under
 * the License.
 */

package org.ros.internal.node.server.master;

import java.net.URI;
import java.util.Collection;
import java.util.Collections;
import java.util.Map;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.ros.internal.node.service.ServiceIdentifier;
import org.ros.master.client.TopicSystemState;
import org.ros.namespace.GraphName;
import org.ros.node.service.ServiceServer;

import com.google.common.collect.Maps;

public class MasterRegistrationManagerImpl {

  private static final Log log = LogFactory.getLog(MasterRegistrationManagerImpl.class);

  private final Map<GraphName, NodeRegistrationInfo> nodes;

  private final Map<GraphName, ServiceRegistrationInfo> services;

  private final Map<GraphName, TopicRegistrationInfo> topics;

  private final MasterRegistrationListener listener;

  public MasterRegistrationManagerImpl(MasterRegistrationListener listener) {
    this.listener = listener;
    nodes = Maps.newHashMap();
    services = Maps.newConcurrentMap();
    topics = Maps.newHashMap();
  }

  public TopicRegistrationInfo registerPublisher(GraphName nodeName, URI nodeSlaveUri,
      GraphName topicName, String topicMessageType) {
    if (log.isDebugEnabled()) {
      log.debug(String.format(
          "Registering publisher topic %s with message type %s on node %s with slave URI %s",
          topicName, topicMessageType, nodeName, nodeSlaveUri));
    }

    TopicRegistrationInfo topic = obtainTopicRegistrationInfo(topicName, true);
    NodeRegistrationInfo node = obtainNodeRegistrationInfo(nodeName, nodeSlaveUri);
    topic.addPublisher(node, topicMessageType);
    node.addPublisher(topic);

    return topic;
  }

  public boolean unregisterPublisher(GraphName nodeName, GraphName topicName) {
    if (log.isDebugEnabled()) {
      log.debug(String.format("Unregistering publisher of topic %s from node %s",
          topicName, nodeName));
    }

    TopicRegistrationInfo topic = obtainTopicRegistrationInfo(topicName, false);
    if (topic != null) {
      NodeRegistrationInfo node = nodes.get(nodeName);
      if (node != null) {
        node.removePublisher(topic);
        topic.removePublisher(node);

        potentiallyDeleteNode(node);

        return true;
      } else {
        // never was a node with that name
        if (log.isWarnEnabled()) {
          log.warn(String.format("Received unregister publisher for topic %s on unknown node %s",
              topicName, nodeName));
        }

        return false;
      }
    } else {
      // If no topic, there will be no node registration.
      if (log.isWarnEnabled()) {
        log.warn(String.format("Received unregister publisher for unknown topic %s on node %s",
            topicName, nodeName));
      }

      return false;
    }
  }

  public TopicRegistrationInfo registerSubscriber(GraphName nodeName, URI nodeSlaveUri,
      GraphName topicName, String topicMessageType) {
    if (log.isDebugEnabled()) {
      log.debug(String.format(
          "Registering subscriber topic %s with message type %s on node %s with slave URI %s",
          topicName, topicMessageType, nodeName, nodeSlaveUri));
    }

    TopicRegistrationInfo topic = obtainTopicRegistrationInfo(topicName, true);
    NodeRegistrationInfo node = obtainNodeRegistrationInfo(nodeName, nodeSlaveUri);
    topic.addSubscriber(node, topicMessageType);
    node.addSubscriber(topic);

    return topic;
  }

  public boolean unregisterSubscriber(GraphName nodeName, GraphName topicName) {
    if (log.isDebugEnabled()) {
      log.debug(String.format("Unregistering subscriber of topic %s from node %s",
          topicName, nodeName));
    }

    TopicRegistrationInfo topic = obtainTopicRegistrationInfo(topicName, false);
    if (topic != null) {
      NodeRegistrationInfo node = nodes.get(nodeName);
      if (node != null) {
        node.removeSubscriber(topic);
        topic.removeSubscriber(node);
        potentiallyDeleteNode(node);
        return true;
      } else {
        // never was a node with that name
        if (log.isWarnEnabled()) {
          log.warn(String.format("Received unregister subscriber for topic %s on unknown node %s",
              topicName, nodeName));
        }
        return false;
      }
    } else {
      // If no topic, there will be no node registration.
      if (log.isWarnEnabled()) {
        log.warn(String.format("Received unregister subscriber for unknown topic %s on node %s",
            topicName, nodeName));
      }
      return false;
    }
  }

  public ServiceRegistrationInfo registerService(GraphName nodeName, URI nodeSlaveUri,
      GraphName serviceName, URI serviceUri) {
    if (log.isDebugEnabled()) {
      log.debug(String.format(
          "Registering service %s with server URI %s on node %s with slave URI %s", serviceName,
          serviceUri, nodeName, nodeSlaveUri));
    }

    NodeRegistrationInfo node = obtainNodeRegistrationInfo(nodeName, nodeSlaveUri);

    ServiceRegistrationInfo service = services.get(serviceName);
    if (service != null) {
      NodeRegistrationInfo previousServiceNode = service.getNode();
      if (previousServiceNode == node) {
        // If node is the same, no need to do anything
        if (log.isWarnEnabled()) {
          log.warn(String
              .format(
                  "Registering already known service %s with server URI %s on node %s with slave URI %s",
                  serviceName, serviceUri, nodeName, nodeSlaveUri));
        }
        return service;
      } else {
        // The service's node is changing.
        previousServiceNode.removeService(service);
        potentiallyDeleteNode(previousServiceNode);
      }
    }

    // Service didn't exist or the node is changing.
    service = new ServiceRegistrationInfo(serviceName, serviceUri, node);
    node.addService(service);

    services.put(serviceName, service);

    return service;
  }

  public boolean unregisterService(GraphName nodeName, GraphName serviceName, URI serviceUri) {
    if (log.isDebugEnabled()) {
      log.debug(String.format("Unregistering service %s from node %s", serviceName, nodeName));
    }

    ServiceRegistrationInfo service = services.get(serviceName);
    if (service != null) {
      NodeRegistrationInfo node = nodes.get(nodeName);
      if (node != null) {
        // No need to keep service around.
        services.remove(serviceName);

        node.removeService(service);
        potentiallyDeleteNode(node);

        return true;
      } else {
        // never was a node with that name
        if (log.isWarnEnabled()) {
          log.warn(String.format("Received unregister for service %s on unknown node %s",
              serviceName, nodeName));
        }

        // TODO(keith): Should the node be removed anyway, or should only its
        // real node be able to unregister it?

        return false;
      }
    } else {
      // If no service, there will be no node registration.
      if (log.isWarnEnabled()) {
        log.warn(String.format("Received unregister for unknown service %s on node %s",
            serviceName, nodeName));
      }

      return false;
    }
  }

  public Collection<TopicRegistrationInfo> getAllTopics() {
    return Collections.unmodifiableCollection(topics.values());
  }

  public TopicRegistrationInfo getTopicRegistrationInfo(GraphName topicName) {
    return topics.get(topicName);
  }

  public NodeRegistrationInfo getNodeRegistrationInfo(GraphName nodeName) {
    return nodes.get(nodeName);
  }

  public Collection<ServiceRegistrationInfo> getAllServices() {
    return Collections.unmodifiableCollection(services.values());
  }

  public ServiceRegistrationInfo getServiceRegistrationInfo(GraphName serviceName) {
    return services.get(serviceName);
  }

  private TopicRegistrationInfo obtainTopicRegistrationInfo(GraphName topicName,
      boolean shouldCreate) {
    TopicRegistrationInfo info = topics.get(topicName);
    if (info == null && shouldCreate) {
      info = new TopicRegistrationInfo(topicName);
      topics.put(topicName, info);
    }

    return info;
  }

  private NodeRegistrationInfo obtainNodeRegistrationInfo(GraphName nodeName, URI nodeSlaveUri) {
    NodeRegistrationInfo node = nodes.get(nodeName);
    if (node != null) {
      // The node exists. Any need to shut it down?
      if (node.getNodeSlaveUri().equals(nodeSlaveUri)) {
        // OK, same URI so can just return it.
        return node;
      }

      // The node is switching slave URIs, so we need a new one.
      potentiallyDeleteNode(node);
      cleanupNode(node);
      try {
        listener.onNodeReplacement(node);
      } catch (Exception e) {
        // No matter what, we want to keep going
        log.error("Error during onNodeReplacement call", e);
      }
    }

    // Either no existing node, or the old node needs to go away
    node = new NodeRegistrationInfo(nodeName, nodeSlaveUri);
    nodes.put(nodeName, node);

    return node;
  }

  private void cleanupNode(NodeRegistrationInfo node) {
    for (TopicRegistrationInfo topic : node.getPublishers()) {
      topic.removePublisher(node);
    }

    for (TopicRegistrationInfo topic : node.getSubscribers()) {
      topic.removeSubscriber(node);
    }

    for (ServiceRegistrationInfo service : node.getServices()) {
      services.remove(service.getServiceName());
    }
  }

  private void potentiallyDeleteNode(NodeRegistrationInfo node) {
    if (!node.hasRegistrations()) {
      nodes.remove(node.getNodeName());
    }
  }
}