SwitchableMasterUriProvider.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.master.uri;

import com.google.common.collect.Lists;

import org.ros.exception.RosRuntimeException;

import java.net.URI;
import java.util.List;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;

public class SwitchableMasterUriProvider implements MasterUriProvider {

  private final Object mutex;

  private MasterUriProvider provider;

  private List<ProviderRequest> pending = Lists.newArrayList();

  public SwitchableMasterUriProvider(MasterUriProvider provider) {
    this.provider = provider;
    mutex = new Object();
  }

  @Override
  public URI getMasterUri() throws RosRuntimeException {
    MasterUriProvider providerToUse = null;
    ProviderRequest requestToUse = null;

    synchronized (mutex) {
      if (provider != null) {
        providerToUse = provider;
      } else {
        requestToUse = new ProviderRequest();
        pending.add(requestToUse);
      }
    }

    if (providerToUse != null) {
      return providerToUse.getMasterUri();
    } else {
      return requestToUse.getMasterUri();
    }
  }

  @Override
  public URI getMasterUri(long timeout, TimeUnit unit) {
    // We can't really switch providers, but people are willing to wait. It
    // seems appropriate to wait rather than to return immediately.

    MasterUriProvider providerToUse = null;
    synchronized (mutex) {
      if (provider != null) {
        providerToUse = provider;
      }
    }

    if (providerToUse != null) {
      return providerToUse.getMasterUri(timeout, unit);
    } else {
      try {
        Thread.sleep(unit.toMillis(timeout));
      } catch (InterruptedException e) {
        // Don't care
      }

      return null;
    }
  }

  public void switchProvider(MasterUriProviderSwitcher switcher) {
    synchronized (mutex) {
      MasterUriProvider oldProvider = provider;
      provider = switcher.switchProvider(oldProvider);

      if (oldProvider == null) {
        for (ProviderRequest request : pending) {
          request.setProvider(provider);
        }
        pending.clear();
      }
    }
  }

  public interface MasterUriProviderSwitcher {

    MasterUriProvider switchProvider(MasterUriProvider oldProvider);
  }

  private static class ProviderRequest {

    private CountDownLatch latch = new CountDownLatch(1);

    private MasterUriProvider provider;

    public URI getMasterUri() {
      try {
        latch.await();
        return provider.getMasterUri();
      } catch (InterruptedException e) {
        throw new RosRuntimeException("URI provider interrupted", e);
      }
    }

    public void setProvider(MasterUriProvider provider) {
      this.provider = provider;
      latch.countDown();
    }
  }
}