DnsSdDiscoveryLocator.java

/*******************************************************************************
 * Copyright (c) 2009 Markus Alexander Kuppe.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     Markus Alexander Kuppe (ecf-dev_eclipse.org <at> lemmster <dot> de) - initial API and implementation
 ******************************************************************************/
package org.eclipse.ecf.provider.dnssd;

import java.net.URI;
import java.net.UnknownHostException;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import java.util.Properties;

import org.eclipse.core.runtime.Assert;
import org.eclipse.ecf.core.ContainerConnectException;
import org.eclipse.ecf.core.events.ContainerConnectedEvent;
import org.eclipse.ecf.core.events.ContainerConnectingEvent;
import org.eclipse.ecf.core.identity.ID;
import org.eclipse.ecf.core.identity.IDCreateException;
import org.eclipse.ecf.core.identity.IDFactory;
import org.eclipse.ecf.core.identity.Namespace;
import org.eclipse.ecf.core.security.IConnectContext;
import org.eclipse.ecf.discovery.DiscoveryContainerConfig;
import org.eclipse.ecf.discovery.IServiceInfo;
import org.eclipse.ecf.discovery.ServiceInfo;
import org.eclipse.ecf.discovery.ServiceProperties;
import org.eclipse.ecf.discovery.identity.IServiceID;
import org.eclipse.ecf.discovery.identity.IServiceTypeID;
import org.xbill.DNS.Lookup;
import org.xbill.DNS.Name;
import org.xbill.DNS.PTRRecord;
import org.xbill.DNS.Record;
import org.xbill.DNS.ResolverConfig;
import org.xbill.DNS.SRVRecord;
import org.xbill.DNS.SimpleResolver;
import org.xbill.DNS.TXTRecord;
import org.xbill.DNS.Type;

/**
 * @author markus
 *
 */
public class DnsSdDiscoveryLocator extends DnsSdDiscoveryContainerAdapter {

	private static final String DNS_SD_PATH = "path"; //$NON-NLS-1$
	private static final String DNS_SD_PTCL = "dns-sd.ptcl"; //$NON-NLS-1$

	public DnsSdDiscoveryLocator() {
		super(DnsSdNamespace.NAME, new DiscoveryContainerConfig(IDFactory
				.getDefault().createStringID(
						DnsSdDiscoveryLocator.class.getName())));
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see
	 * org.eclipse.ecf.discovery.IDiscoveryLocator#getServiceInfo(org.eclipse
	 * .ecf.discovery.identity.IServiceID)
	 */
	public IServiceInfo getServiceInfo(IServiceID aServiceId) {
		Assert.isNotNull(aServiceId);
		IServiceInfo[] services = getServices(aServiceId.getServiceTypeID());
		for (int i = 0; i < services.length; i++) {
			//TODO This can be a lot faster if done directly instead of via org.eclipse.ecf.provider.dnssrv.DnsSrvDisocoveryLocator.getServices(IServiceTypeID)
			IServiceInfo iServiceInfo = services[i];
			if(iServiceInfo.getServiceID().equals(aServiceId)) {
				return iServiceInfo;
			}
		}
		return null;
	}

	/**
	 * This always returns the service type found for our local domain
	 * Use org.eclipse.ecf.provider.dnssrv.DnsSrvDisocoveryLocator.getServices(IServiceTypeID) with a wildcard query instead.
	 * 
	 * @see org.eclipse.ecf.discovery.IDiscoveryLocator#getServiceTypes()
	 */
	public IServiceTypeID[] getServiceTypes() {
		// technically can't do anything without a scope (domain) -> falling back to local domain (mDNS?)
		DnsSdServiceTypeID serviceTypeId = (DnsSdServiceTypeID) targetID;
		return getServiceTypes(serviceTypeId);
	}

	private IServiceTypeID[] getServiceTypes(final DnsSdServiceTypeID serviceTypeId) {
		List result = new ArrayList();
		Record[] queryResult = getRecords(serviceTypeId);
		for (int j = 0; j < queryResult.length; j++) {
			Record record = queryResult[j];
			if(record instanceof PTRRecord) {
				PTRRecord ptrRecord = (PTRRecord) record;
				result.add(new DnsSdServiceTypeID(getServicesNamespace(), ptrRecord.getTarget()));
			} else if (record instanceof SRVRecord) {
				SRVRecord srvRecord = (SRVRecord) record;
				result.add(new DnsSdServiceTypeID(getServicesNamespace(), srvRecord.getName()));
			}
		}
		return (IServiceTypeID[]) result.toArray(new IServiceTypeID[result.size()]);
	}
	
	/*
	 * (non-Javadoc)
	 * 
	 * @see org.eclipse.ecf.discovery.IDiscoveryLocator#getServices()
	 */
	public IServiceInfo[] getServices() {
		// technically can't do anything without a scope (domain) -> falling back to local domain (mDNS?)
		return getServices(targetID);
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see
	 * org.eclipse.ecf.discovery.IDiscoveryLocator#getServices(org.eclipse.ecf
	 * .discovery.identity.IServiceTypeID)
	 */
	public IServiceInfo[] getServices(IServiceTypeID aServiceTypeId) {
		Assert.isNotNull(aServiceTypeId);
		DnsSdServiceTypeID serviceTypeId = (DnsSdServiceTypeID) aServiceTypeId;
		Collection srvRecords = getSRVRecords(serviceTypeId.getInternalQueries());
		List serviceInfos = getServiceInfos(srvRecords);
		return (IServiceInfo[]) serviceInfos.toArray(new IServiceInfo[serviceInfos.size()]);
	}
	
	private List getServiceInfos(Collection srvQueryResult) {
		List infos = new ArrayList();
		for (Iterator iterator = srvQueryResult.iterator(); iterator.hasNext();) {
			SRVRecord srvRecord = (SRVRecord) iterator.next();
			long ttl = srvRecord.getTTL();
			int priority = srvRecord.getPriority();
			int weight = srvRecord.getWeight();
			int port = srvRecord.getPort();
			Name target = srvRecord.getTarget();
			String host = target.toString();
			host = host.substring(0, host.length() - 1);
			
			IServiceTypeID aServiceTypeID = new DnsSdServiceTypeID(getConnectNamespace(), srvRecord.getName());
			
			// query for txt records (attributes)
			Properties props = new Properties();
			Lookup txtQuery = new Lookup(srvRecord.getName(), Type.TXT);
			txtQuery.setResolver(resolver);
			Record[] txtQueryResults = txtQuery.run();
			int length = txtQueryResults == null ? 0 : txtQueryResults.length;
			for (int l = 0; l < length; l++) {
				TXTRecord txtResult = (TXTRecord) txtQueryResults[l];
				List strings = txtResult.getStrings();
				for (Iterator itr = strings.iterator(); itr.hasNext();) {
					String str = (String) itr.next();
					String[] split = str.split("="); //$NON-NLS-1$
					props.put(split[0], split[1]);
				}
			}
			String path = props.getProperty(DNS_SD_PATH);
			String proto = props.getProperty(DNS_SD_PTCL) == null ? aServiceTypeID.getProtocols()[0] : props.getProperty(DNS_SD_PTCL);
			
			URI uri = URI.create(proto + "://" + host + ":" + port + (path == null ? "" : path)); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
			IServiceInfo info =new ServiceInfo(uri, host, aServiceTypeID, priority, weight, new ServiceProperties(props), ttl);
			infos.add(info);
		}
		return infos;
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see
	 * org.eclipse.ecf.core.IContainer#connect(org.eclipse.ecf.core.identity.ID,
	 * org.eclipse.ecf.core.security.IConnectContext)
	 */
	public void connect(ID aTargetID, IConnectContext connectContext)
			throws ContainerConnectException {

		// connect can only be called once
		if (targetID != null || getConfig() == null) {
			throw new ContainerConnectException(Messages.DnsSdDiscoveryLocator_Container_Already_Connected);
		}
		
		// fall back to the search path as last resort 
		if(aTargetID == null || !(aTargetID instanceof DnsSdServiceTypeID)) {
			ResolverConfig config = new ResolverConfig();
			Name[] searchPaths = config.searchPath();
			if(searchPaths != null && searchPaths.length > 0) {
				targetID = new DnsSdServiceTypeID();
				targetID.setSearchPath(searchPaths);
			} else {
				throw new ContainerConnectException(Messages.DnsSdDiscoveryLocator_No_Target_ID);
			}
		} else {
			final Namespace ns = getConnectNamespace();
			try {
				targetID = (DnsSdServiceTypeID) ns.createInstance(new Object[]{aTargetID});
			} catch(IDCreateException e) {
				throw new ContainerConnectException(e);
			}
		}
		
		// instantiate a default resolver
		if(resolver == null) {
			try {
				resolver = new SimpleResolver();
			} catch (UnknownHostException e) {
				throw new ContainerConnectException(e);
			}
		}
		
		// read browsing domains for the given targetID/searchpath and merge with existing
		targetID.addSearchPath(getBrowsingDomains(targetID));

		// done setting up this provider, send event
		fireContainerEvent(new ContainerConnectingEvent(this.getID(), targetID,
				connectContext));
		fireContainerEvent(new ContainerConnectedEvent(this.getID(), targetID));
	}

	private String[] getBrowsingDomains(IServiceTypeID aServiceTypeId) {
		final String[] rrs = new String[] {BnRDnsSdServiceTypeID.BROWSE_DOMAINS, BnRDnsSdServiceTypeID.DEFAULT_BROWSE_DOMAIN};
		final Collection res = getBrowsingOrRegistrationDomains(aServiceTypeId, rrs);
		return (String[]) res.toArray(new String[res.size()]);
	}


	/* (non-Javadoc)
	 * @see org.eclipse.ecf.discovery.AbstractDiscoveryContainerAdapter#getContainerName()
	 */
	public String getContainerName() {
		return Activator.DISCOVERY_CONTAINER_NAME_VALUE + Activator.LOCATOR;
	}
}