Attachment #183464 for bug #257443

Lines 2-7 Link Here

(-)plugin.xml (+10 lines)
2	<?eclipse version="3.2"?>	2	<?eclipse version="3.2"?>
3	<plugin>	3	<plugin>
4	<extension-point id="authenticator" name="Authenticator" schema="schema/authenticator.exsd"/>	4	<extension-point id="authenticator" name="Authenticator" schema="schema/authenticator.exsd"/>
		5	<extension-point id="proxyProvider" name="ProxyProvider" schema="schema/proxyProvider.exsd"/>
5	<extension	6	<extension
6	point="org.eclipse.equinox.preferences.preferences">	7	point="org.eclipse.equinox.preferences.preferences">
7	<initializer	8	<initializer
Lines 11-15 Link Here
11	class="org.eclipse.core.internal.net.PreferenceModifyListener">	12	class="org.eclipse.core.internal.net.PreferenceModifyListener">
12	</modifier>	13	</modifier>
13	</extension>	14	</extension>
		15	<extension
		16	point="org.eclipse.core.net.proxyProvider">
		17	<proxyProvider
		18	class="org.eclipse.core.internal.net.proxy.DirectProxyProvider">
		19	</proxyProvider>
		20	<proxyProvider
		21	class="org.eclipse.core.internal.net.proxy.ManualProxyProvider">
		22	</proxyProvider>
		23	</extension>
14		24
15	</plugin>	25	</plugin>




<?xml version='1.0' encoding='UTF-8'?>
<!-- Schema file written by PDE -->
<schema targetNamespace="org.eclipse.core.net" xmlns="http://www.w3.org/2001/XMLSchema">
<annotation>
      <appInfo>
         <meta.schema plugin="org.eclipse.core.net" id="proxyProvider" name="ProxyProvider"/>
      </appInfo>
      <documentation>
         [Enter description of this extension point.]
      </documentation>
   </annotation>

   <element name="extension">
      <annotation>
         <appInfo>
            <meta.element />
         </appInfo>
      </annotation>
      <complexType>
         <sequence>
            <element ref="proxyProvider" minOccurs="1" maxOccurs="unbounded"/>
         </sequence>
         <attribute name="point" type="string" use="required">
            <annotation>
               <documentation>
                  
               </documentation>
            </annotation>
         </attribute>
         <attribute name="id" type="string">
            <annotation>
               <documentation>
                  
               </documentation>
            </annotation>
         </attribute>
         <attribute name="name" type="string">
            <annotation>
               <documentation>
                  
               </documentation>
               <appInfo>
                  <meta.attribute translatable="true"/>
               </appInfo>
            </annotation>
         </attribute>
      </complexType>
   </element>

   <element name="proxyProvider">
      <complexType>
         <attribute name="class" type="string" use="required">
            <annotation>
               <documentation>
                  
               </documentation>
               <appInfo>
                  <meta.attribute kind="java" basedOn="org.eclipse.core.internal.net.AbstractProxyProvider:"/>
               </appInfo>
            </annotation>
         </attribute>
      </complexType>
   </element>

   <annotation>
      <appInfo>
         <meta.section type="since"/>
      </appInfo>
      <documentation>
         [Enter the first release in which this extension point appears.]
      </documentation>
   </annotation>

   <annotation>
      <appInfo>
         <meta.section type="examples"/>
      </appInfo>
      <documentation>
         [Enter extension point usage example here.]
      </documentation>
   </annotation>

   <annotation>
      <appInfo>
         <meta.section type="apiinfo"/>
      </appInfo>
      <documentation>
         [Enter API information here.]
      </documentation>
   </annotation>

   <annotation>
      <appInfo>
         <meta.section type="implementation"/>
      </appInfo>
      <documentation>
         [Enter information about supplied implementation of this extension point.]
      </documentation>
   </annotation>


</schema>

Lines 20-25 Link Here

(-)src/org/eclipse/core/internal/net/AbstractProxyProvider.java (+4 lines)
20	*/	20	*/
21	public abstract class AbstractProxyProvider {	21	public abstract class AbstractProxyProvider {
22		22
		23	public abstract String getName();
		24
		25	public abstract String getLocalizedName();
		26
23	/**	27	/**
24	* Returns proxies to use with the given URI. Returns empty array	28	* Returns proxies to use with the given URI. Returns empty array
25	* when there is no appropriate proxy.	29	* when there is no appropriate proxy.

Lines 49-54 Link Here

(-)src/org/eclipse/core/internal/net/Activator.java (+2 lines)
49	private static final String PROP_REGISTER_SERVICE = "org.eclipse.net.core.enableProxyService"; //$NON-NLS-1$	49	private static final String PROP_REGISTER_SERVICE = "org.eclipse.net.core.enableProxyService"; //$NON-NLS-1$
50		50
51	public static final String PT_AUTHENTICATOR = "authenticator"; //$NON-NLS-1$	51	public static final String PT_AUTHENTICATOR = "authenticator"; //$NON-NLS-1$
		52
		53	public static final String PT_PROXYPROVIDER = "proxyProvider"; //$NON-NLS-1$
52		54
53	private BundleContext bundleContext;	55	private BundleContext bundleContext;
54		56




/*******************************************************************************
 * Copyright (c) 2007, 2010 IBM Corporation and others.
 * 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


	public ProxyData(String type, String host, int port,
			boolean requiresAuthentication, String source) {
		this.type = resolveType(type);
		this.host = host;
		this.port = port;
		this.requiresAuthentication = requiresAuthentication;

	}

	public ProxyData(String type) {
		this.type = resolveType(type);
	}

	public String getHost() {

	}
	
	public void setType(String type) {
		this.type = resolveType(type);
	}

	public void setHost(String host) {

			return false;
		return true;
	}
	
	private String resolveType(String proxyType) {
		if (IProxyData.HTTP_PROXY_TYPE.equalsIgnoreCase(proxyType)) {
			return IProxyData.HTTP_PROXY_TYPE;
		} else if (IProxyData.HTTPS_PROXY_TYPE.equalsIgnoreCase(proxyType)) {
			return IProxyData.HTTPS_PROXY_TYPE;
		} else if (IProxyData.SOCKS_PROXY_TYPE.equalsIgnoreCase(proxyType)) {
			return IProxyData.SOCKS_PROXY_TYPE;
		}
		throw new IllegalArgumentException("Incorrect proxy data type."); //$NON-NLS-1$
	}

}




import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.Properties;
import java.util.TreeMap;

import org.eclipse.core.net.proxy.IProxyChangeEvent;
import org.eclipse.core.net.proxy.IProxyChangeListener;

	static final String PREF_NON_PROXIED_HOSTS = "nonProxiedHosts"; //$NON-NLS-1$
	static final String PREF_ENABLED = "proxiesEnabled"; //$NON-NLS-1$
	static final String PREF_OS = "systemProxiesEnabled"; //$NON-NLS-1$
	static final String PREF_CUSTOM_PROVIDER = "customProxyProvider"; //$NON-NLS-1$
	
	private static IProxyService proxyManager;

	private Map providers;
	
	private PreferenceManager preferenceManager;
	

		};

	private ProxyManager() {
		providers = new TreeMap();
			nativeProxyProvider = (AbstractProxyProvider) Class.forName(
					"org.eclipse.core.net.ProxyProvider").newInstance(); //$NON-NLS-1$
		} catch (ClassNotFoundException e) {
			// no class found
		} catch (Exception e) {
			Activator.logInfo("Problems occured during the proxy provider initialization.", e); //$NON-NLS-1$
		}
		preferenceManager = Activator.getInstance().getPreferenceManager();
	}
	
	private void initializeProxyProviders() {
		IExtension[] extensions = RegistryFactory.getRegistry().getExtensionPoint(Activator.ID, Activator.PT_PROXYPROVIDER).getExtensions();
		if (extensions.length == 0) {
			return;
		}
		for (int i = 0; i < extensions.length; i++) {
			IConfigurationElement[] configs = extensions[i].getConfigurationElements();
			for (int j = 0; j < configs.length; j++) {
				try {
					Object object = configs[j].createExecutableExtension("class"); //$NON-NLS-1$
					if (object instanceof AbstractProxyProvider) {
						AbstractProxyProvider provider = (AbstractProxyProvider) object;
						if (!providers.containsKey(provider.getName())) {
							providers.put(provider.getName(), provider);
						}
					}
				} catch (CoreException e) {
					Activator.logError("Cannot initialize proxy provider", e); //$NON-NLS-1$
				}
			}
		}
	}
	
	AbstractProxyProvider getProviderByName(String name) {
		AbstractProxyProvider provider = (AbstractProxyProvider) providers.get(name);
		if (provider == null) {
			throw new IllegalArgumentException("Provider not supported"); //$NON-NLS-1$
		}
		return provider;
	}
	
	String getCustomProxyProvider() {
		String provider = preferenceManager.getString(PreferenceManager.ROOT, PREF_CUSTOM_PROVIDER);
		if (provider != null && providers.containsKey(provider)) {
			return provider;
		}
		if (hasSystemProxies()) {
			return "Native"; //$NON-NLS-1$
		}
		return null;
	}

	/**
	 * Return the proxy manager.

		System.arraycopy(nonProxiedHosts, 0, result, 0, nonProxiedHosts.length );
		return result;
	}
	
	public String[] getNativeNonProxiedHosts() {
		if (hasSystemProxies()) {
			return nativeProxyProvider.getNonProxiedHosts();
		}
		return new String[0];
	}

	/* (non-Javadoc)
	 * @see org.eclipse.core.net.IProxyManager#setNonProxiedHosts(java.lang.String[])
	 */

			ProxyType type = proxies[i];
			result[i] = type.getProxyData(ProxyType.VERIFY_EQUAL);
		}
		return result;
	}

	public IProxyData[] getNativeProxyData() {
		if (hasSystemProxies()) {
			return resolveType(nativeProxyProvider.getProxyData());
		}
		return new IProxyData[0];
	}

	public void setProxyData(IProxyData[] proxies) {
		checkMigrated();
		doSetProxyData(proxies);
	}
	
	private void doSetProxyData(IProxyData[] proxyDatas) {
		IProxyData[] oldData = getProxyData();
		String[] hosts = getNonProxiedHosts();
		IProxyData[] changedProxies = internalSetProxyData(proxies);
		if (changedProxies.length > 0) {
			IProxyChangeEvent event = new ProxyChangeEvent(IProxyChangeEvent.PROXY_SERVICE_ENABLEMENT_CHANGE, hosts, hosts, oldData, changedProxies);
			fireChange(event);
		}
	}
	
	private IProxyData[] internalSetProxyData(IProxyData[] proxyDatas) {
		List result = new ArrayList();
		for (int i = 0; i < proxyDatas.length; i++) {

	}

	public void initialize() {
		initializeProxyProviders();
		checkMigrated();
		preferenceManager.addPreferenceChangeListener(PreferenceManager.ROOT, this);
		// Now initialize each proxy type


	public IProxyData getProxyData(String type) {
		checkMigrated();
		return internalGetProxyData(type, ProxyType.VERIFY_EQUAL);
	}

	private IProxyData internalGetProxyData(String type, int verifySystemProperties) {


	public IProxyData[] getProxyDataForHost(String host) {
		checkMigrated();
		if (!internalIsProxiesEnabled()) {
			return new IProxyData[0];
		}
		URI uri = tryGetURI(host);
		return select(uri);
			return new IProxyData[0];
		}
		if (hasSystemProxies() && isSystemProxiesEnabled()) {
			return resolveType(nativeProxyProvider.select(uri));
		}

		if (isHostFiltered(uri))
			return new IProxyData[0];
		IProxyData[] data = getProxyData();
		List result = new ArrayList();
		for (int i = 0; i < data.length; i++) {
			IProxyData proxyData = data[i];
			if (proxyData.getHost() != null)
				result.add(proxyData);
		}
		IProxyData ret[] = (IProxyData[]) result.toArray(new IProxyData[result.size()]);
		return resolveType(ret);
	}

	public static URI tryGetURI(String host) {

		}
	}

	private boolean isHostFiltered(URI uri) {
		String[] filters = getNonProxiedHosts();
		for (int i = 0; i < filters.length; i++) {
			String filter = filters[i];
			if (matchesFilter(uri.getHost(), filter))
				return true;
		}
		return false;
	}

	private boolean matchesFilter(String host, String filter) {
		StringMatcher matcher = new StringMatcher(filter, true, false);
		return matcher.match(host);
	}

	/* (non-Javadoc)
	 * @see org.eclipse.net.core.IProxyManager#getProxyDataForHost(java.lang.String, java.lang.String)
	 */
	public IProxyData getProxyDataForHost(String host, String type) {
		checkMigrated();
		try {
			URI uri = new URI(type, "//" + host, null); //$NON-NLS-1$
			IProxyData[] proxyDatas = select(uri);
			return proxyDatas.length > 0 ? proxyDatas[0] : null;
		} catch (URISyntaxException e) {
			return null;
		}
		if (hasSystemProxies() && isSystemProxiesEnabled())
			try {
				URI uri = new URI(type, "//" + host, null); //$NON-NLS-1$
				IProxyData[] proxyDatas = nativeProxyProvider.select(uri);
				return proxyDatas.length > 0 ? resolveType(proxyDatas[0]) : null;
			} catch (URISyntaxException e) {
				return null;
			}
			
		IProxyData[] data = getProxyDataForHost(host);
		for (int i = 0; i < data.length; i++) {
			IProxyData proxyData = data[i];
			if (proxyData.getType().equalsIgnoreCase(type)
					&& proxyData.getHost() != null)
				return resolveType(proxyData);
		}
		return null;
	}
	
	private void registerAuthenticator() {

	}

	public void preferenceChange(PreferenceChangeEvent event) {
		if (event.getKey().equals(PREF_ENABLED) || event.getKey().equals(PREF_OS) || event.getKey().equals(PREF_CUSTOM_PROVIDER)) {
			checkMigrated();
			internalSetEnabled(preferenceManager.getBoolean(PreferenceManager.ROOT, PREF_ENABLED),
					preferenceManager.getBoolean(PreferenceManager.ROOT, PREF_OS));

	}

	public boolean hasSystemProxies() {
		return providers.containsKey("Native") ? true : false; //$NON-NLS-1$
	}

	public boolean isSystemProxiesEnabled() {

	}

	public IProxyData[] select(URI uri) {
		if (uri == null) {
			throw new IllegalArgumentException("Illegal argument value: " + uri); //$NON-NLS-1$
			return resolveType(new IProxyData[] { data });
		}
		if ("file".equals(uri.getScheme())) { //$NON-NLS-1$
			return new IProxyData[0];

	public IProxyData resolveType(IProxyData data) {
		if (data == null) {
			return null;
		}
		if (uri.getHost() == null) {
			uri = tryGetURI(uri.toString());
			d.setType(IProxyData.HTTP_PROXY_TYPE);
		} else if (d.getType().equalsIgnoreCase(IProxyData.HTTPS_PROXY_TYPE)) {
			d.setType(IProxyData.HTTPS_PROXY_TYPE);
		} else if (d.getType().equalsIgnoreCase(IProxyData.SOCKS_PROXY_TYPE)) {
			d.setType(IProxyData.SOCKS_PROXY_TYPE);
		}
		return internalIsProxiesEnabled() ? getProviderByName(getProxyProvider()).select(uri) : new IProxyData[0];
	}

	public void setProxyProvider(String name) {
		preferenceManager.putString(PreferenceManager.ROOT, PREF_CUSTOM_PROVIDER, getProviderByName(name).getName());
	}
	
	public String getProxyProvider() {
		return ProxySelector.getDefaultProvider();
	}

	public String[] getAvailableProxyProviders() {
		return (String[]) providers.keySet().toArray(new String[0]);
	}

}

Lines 1-5 Link Here

(-)src/org/eclipse/core/internal/net/ProxySelector.java (-80 / +45 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright (c) 2008, 2009 IBM Corporation and others.	2	* Copyright (c) 2008, 2010 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials	3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0	4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at	5	* which accompanies this distribution, and is available at
Lines 11-19 Link Here
11	package org.eclipse.core.internal.net;	11	package org.eclipse.core.internal.net;
12		12
13	import org.eclipse.core.net.proxy.IProxyData;	13	import org.eclipse.core.net.proxy.IProxyData;
14	import org.eclipse.core.net.proxy.IProxyService;
15	import org.eclipse.core.runtime.Assert;	14	import org.eclipse.core.runtime.Assert;
16	import org.eclipse.core.runtime.CoreException;
17		15
18	/**	16	/**
19	* This class adapts ProxyManager to add additional layer of providers on its	17	* This class adapts ProxyManager to add additional layer of providers on its
Lines 22-96 Link Here
22	public class ProxySelector {	20	public class ProxySelector {
23		21
24	private static final String DIRECT_PROVIDER = "Direct"; //$NON-NLS-1$	22	private static final String DIRECT_PROVIDER = "Direct"; //$NON-NLS-1$
25	private static final String ECLIPSE_PROVIDER = "Manual"; //$NON-NLS-1$	23	private static final String MANUAL_PROVIDER = "Manual"; //$NON-NLS-1$
26	private static final String NATIVE_PROVIDER = "Native"; //$NON-NLS-1$	24
		25	private static ProxyManager manager;
		26
		27	static {
		28	manager = (ProxyManager) ProxyManager.getProxyManager();
		29	}
27		30
28	public static String[] getProviders() {	31	public static String[] getProviders() {
29	return new String[] { DIRECT_PROVIDER, ECLIPSE_PROVIDER,	32	return manager.getAvailableProxyProviders();
30	NATIVE_PROVIDER };
31	}	33	}
32		34
33	public static String unlocalizeProvider(String name) {	35	public static String unlocalizeProvider(String name) {
34	if (Messages.ProxySelector_0.equals(name)) {	36	String[] providers = manager.getAvailableProxyProviders();
35	return DIRECT_PROVIDER;	37	for (int i = 0; i < providers.length; i++) {
36	} else if (Messages.ProxySelector_1.equals(name)) {	38	AbstractProxyProvider provider = manager.getProviderByName(providers[i]);
37	return ECLIPSE_PROVIDER;	39	if (provider.getLocalizedName().equals(name)) {
38	} else if (Messages.ProxySelector_2.equals(name)) {	40	return provider.getName();
39	return NATIVE_PROVIDER;	41	}
40	}	42	}
41	Assert.isTrue(false);	43	Assert.isTrue(false);
42	return null;	44	return null;
43	}	45	}
44		46
45	public static String localizeProvider(String name) {	47	public static String localizeProvider(String name) {
46	if (DIRECT_PROVIDER.equals(name)) {	48	AbstractProxyProvider proxyProvider = manager.getProviderByName(name);
47	return Messages.ProxySelector_0;	49	String localizedName = proxyProvider.getLocalizedName();
48	} else if (ECLIPSE_PROVIDER.equals(name)) {	50	if (localizedName != null) {
49	return Messages.ProxySelector_1;	51	return localizedName;
50	} else if (NATIVE_PROVIDER.equals(name)) {
51	return Messages.ProxySelector_2;
52	}	52	}
53	Assert.isTrue(false);	53	Assert.isTrue(false);
54	return null;	54	return null;
55	}	55	}
56		56
57	public static String getDefaultProvider() {	57	public static String getDefaultProvider() {
58	IProxyService service = ProxyManager.getProxyManager();	58	if (!manager.isProxiesEnabled()) {
59	if (!service.isProxiesEnabled()) {
60	return DIRECT_PROVIDER;	59	return DIRECT_PROVIDER;
61	} else if (service.isProxiesEnabled()	60	}
62	&& !service.isSystemProxiesEnabled()) {	61	if (!manager.isSystemProxiesEnabled()) {
63	return ECLIPSE_PROVIDER;	62	return MANUAL_PROVIDER;
64	}	63	}
65	return NATIVE_PROVIDER;	64	String provider = manager.getCustomProxyProvider();
		65	return provider != null ? provider : DIRECT_PROVIDER;
66	}	66	}
67		67
68	public static void setActiveProvider(String provider) {	68	public static void setActiveProvider(String provider) {
69	IProxyService service = ProxyManager.getProxyManager();
70	if (provider.equals(DIRECT_PROVIDER)) {	69	if (provider.equals(DIRECT_PROVIDER)) {
71	service.setProxiesEnabled(false);	70	manager.setProxiesEnabled(false);
72	service.setSystemProxiesEnabled(false);	71	manager.setSystemProxiesEnabled(false);
73	} else if (provider.equals(ECLIPSE_PROVIDER)) {	72	} else if (provider.equals(MANUAL_PROVIDER)) {
74	service.setProxiesEnabled(true);	73	manager.setProxiesEnabled(true);
75	service.setSystemProxiesEnabled(false);	74	manager.setSystemProxiesEnabled(false);
76	} else if (provider.equals(NATIVE_PROVIDER)) {
77	service.setProxiesEnabled(true);
78	service.setSystemProxiesEnabled(true);
79	} else {	75	} else {
80	throw new IllegalArgumentException("Provider not supported"); //$NON-NLS-1$	76	manager.setProxiesEnabled(true);
		77	manager.setSystemProxiesEnabled(true);
		78	manager.setProxyProvider(provider);
81	}	79	}
		80
82	}	81	}
83		82
84	public static ProxyData[] getProxyData(String provider) {	83	public static ProxyData[] getProxyData(String provider) {
85	ProxyManager manager = (ProxyManager) ProxyManager.getProxyManager();	84	AbstractProxyProvider proxyProvider = manager.getProviderByName(provider);
86	if (provider.equals(DIRECT_PROVIDER)) {	85	return castArray(proxyProvider.getProxyData());
87	return new ProxyData[0];
88	} else if (provider.equals(ECLIPSE_PROVIDER)) {
89	return castArray(manager.getProxyData());
90	} else if (provider.equals(NATIVE_PROVIDER)) {
91	return castArray(manager.getNativeProxyData());
92	}
93	throw new IllegalArgumentException("Provider not supported"); //$NON-NLS-1$
94	}	86	}
95		87
96	private static ProxyData[] castArray(IProxyData data[]) {	88	private static ProxyData[] castArray(IProxyData data[]) {
Lines 100-114 Link Here
100	}	92	}
101		93
102	public static void setProxyData(String provider, ProxyData proxies[]) {	94	public static void setProxyData(String provider, ProxyData proxies[]) {
103	if (provider.equals(ECLIPSE_PROVIDER)) {	95	if (canSetProxyData(provider)) {
104	IProxyService service = ProxyManager.getProxyManager();	96	manager.setProxyData(proxies);
105	try {
106	service.setProxyData(proxies);
107	} catch (CoreException e) {
108	// Should never occur since ProxyManager does not
109	// declare CoreException to be thrown
110	throw new RuntimeException(e);
111	}
112	} else {	97	} else {
113	throw new IllegalArgumentException(	98	throw new IllegalArgumentException(
114	"Provider does not support setting proxy data"); //$NON-NLS-1$	99	"Provider does not support setting proxy data"); //$NON-NLS-1$
Lines 116-149 Link Here
116	}	101	}
117		102
118	public static boolean canSetProxyData(String provider) {	103	public static boolean canSetProxyData(String provider) {
119	if (provider.equals(ECLIPSE_PROVIDER)) {	104	return provider.equals(MANUAL_PROVIDER);
120	return true;
121	}
122	return false;
123	}	105	}
124		106
125	public static String[] getBypassHosts(String provider) {	107	public static String[] getBypassHosts(String provider) {
126	ProxyManager manager = (ProxyManager) ProxyManager.getProxyManager();	108	AbstractProxyProvider proxyProvider = manager.getProviderByName(provider);
127	if (provider.equals(DIRECT_PROVIDER)) {	109	return proxyProvider.getNonProxiedHosts();
128	return new String[0];
129	} else if (provider.equals(ECLIPSE_PROVIDER)) {
130	return manager.getNonProxiedHosts();
131	} else if (provider.equals(NATIVE_PROVIDER)) {
132	return manager.getNativeNonProxiedHosts();
133	}
134	throw new IllegalArgumentException("Provider not supported"); //$NON-NLS-1$
135	}	110	}
136		111
137	public static void setBypassHosts(String provider, String hosts[]) {	112	public static void setBypassHosts(String provider, String hosts[]) {
138	if (provider.equals(ECLIPSE_PROVIDER)) {	113	if (canSetBypassHosts(provider)) {
139	IProxyService service = ProxyManager.getProxyManager();	114	manager.setNonProxiedHosts(hosts);
140	try {
141	service.setNonProxiedHosts(hosts);
142	} catch (CoreException e) {
143	// Should never occur since ProxyManager does not
144	// declare CoreException to be thrown
145	throw new RuntimeException(e);
146	}
147	} else {	115	} else {
148	throw new IllegalArgumentException(	116	throw new IllegalArgumentException(
149	"Provider does not support setting bypass hosts"); //$NON-NLS-1$	117	"Provider does not support setting bypass hosts"); //$NON-NLS-1$
Lines 151-160 Link Here
151	}	119	}
152		120
153	public static boolean canSetBypassHosts(String provider) {	121	public static boolean canSetBypassHosts(String provider) {
154	if (provider.equals(ECLIPSE_PROVIDER)) {	122	return provider.equals(MANUAL_PROVIDER);
155	return true;
156	}
157	return false;
158	}	123	}
159		124
160	}	125	}

Lines 18-23 Link Here

(-)src/org/eclipse/core/internal/net/WindowsProxyProvider.java (+10 lines)
18		18
19	public class WindowsProxyProvider extends AbstractProxyProvider {	19	public class WindowsProxyProvider extends AbstractProxyProvider {
20		20
		21	private static String NAME = "Native"; //$NON-NLS-1$
		22
21	private static final String LIBRARY_NAME = "jWinHttp-1.0.0"; //$NON-NLS-1$	23	private static final String LIBRARY_NAME = "jWinHttp-1.0.0"; //$NON-NLS-1$
22		24
23	private static boolean jWinHttpLoaded = false;	25	private static boolean jWinHttpLoaded = false;
Lines 44-49 Link Here
44	}	46	}
45	}	47	}
46		48
		49	public String getName() {
		50	return NAME;
		51	}
		52
		53	public String getLocalizedName() {
		54	return Messages.ProxySelector_2;
		55	}
		56
47	public IProxyData[] select(URI uri) {	57	public IProxyData[] select(URI uri) {
48	IProxyData[] proxies = new IProxyData[0];	58	IProxyData[] proxies = new IProxyData[0];
49	if (jWinHttpLoaded) {	59	if (jWinHttpLoaded) {




/*******************************************************************************
 * Copyright (c) 2010 IBM Corporation and others.
 * 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:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
package org.eclipse.core.internal.net.proxy;

import java.net.URI;

import org.eclipse.core.internal.net.AbstractProxyProvider;
import org.eclipse.core.internal.net.Messages;
import org.eclipse.core.net.proxy.IProxyData;

public class DirectProxyProvider extends AbstractProxyProvider {

	private static String NAME = "Direct"; //$NON-NLS-1$
	
	public String getName() {
		return NAME;
	}

	public String getLocalizedName() {
		return Messages.ProxySelector_0;
	}
	
	public IProxyData[] select(URI uri) {
		return new IProxyData[0];
	}

	protected IProxyData[] getProxyData() {
		return new IProxyData[0];
	}

	protected String[] getNonProxiedHosts() {
		return new String[0];
	}

}




/*******************************************************************************
 * Copyright (c) 2010 IBM Corporation and others.
 * 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:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
package org.eclipse.core.internal.net.proxy;

import java.net.URI;
import java.util.ArrayList;
import java.util.List;

import org.eclipse.core.internal.net.AbstractProxyProvider;
import org.eclipse.core.internal.net.Messages;
import org.eclipse.core.internal.net.ProxyManager;
import org.eclipse.core.internal.net.StringMatcher;
import org.eclipse.core.net.proxy.IProxyData;

public class ManualProxyProvider extends AbstractProxyProvider {

	private static String NAME = "Manual"; //$NON-NLS-1$
	
	public String getName() {
		return NAME;
	}
	
	public String getLocalizedName() {
		return Messages.ProxySelector_1;
	}
	
	public IProxyData[] select(URI uri) {
		String[] nonProxyHosts = getNonProxiedHosts();
		if (nonProxyHosts != null) {
			String host = uri.getHost();
			for (int npIndex = 0; npIndex < nonProxyHosts.length; npIndex++) {
				if (matchesFilter(host, nonProxyHosts[npIndex])) {
 					return new IProxyData[0];
 				}
			}
		}
		
		IProxyData[] data = getProxyData();
		List result = new ArrayList();
		for (int i = 0; i < data.length; i++) {
			IProxyData proxyData = data[i];
			if (proxyData.getHost() != null)
				result.add(proxyData);
		}
		data = (IProxyData[]) result.toArray(new IProxyData[result.size()]);
		if (uri.getScheme() == null) {
			return data;
		}
		for (int i = 0; i < data.length; i++) {
			IProxyData proxyData = data[i];
			if (proxyData.getType().equalsIgnoreCase(uri.getScheme()) && proxyData.getHost() != null) {
				return new IProxyData[] { proxyData };
			}	
		}
		return new IProxyData[0];
	}

	protected IProxyData[] getProxyData() {
		return ProxyManager.getProxyManager().getProxyData();
	}

	protected String[] getNonProxiedHosts() {
		return ProxyManager.getProxyManager().getNonProxiedHosts();
	}
	
	private boolean matchesFilter(String host, String filter) {
		StringMatcher matcher = new StringMatcher(filter, true, false);
		return matcher.match(host);
	}

}

Lines 19-24 Link Here

(-)src/org/eclipse/core/internal/net/proxy/unix/UnixProxyProvider.java (+11 lines)
19		19
20	import org.eclipse.core.internal.net.AbstractProxyProvider;	20	import org.eclipse.core.internal.net.AbstractProxyProvider;
21	import org.eclipse.core.internal.net.Activator;	21	import org.eclipse.core.internal.net.Activator;
		22	import org.eclipse.core.internal.net.Messages;
22	import org.eclipse.core.internal.net.Policy;	23	import org.eclipse.core.internal.net.Policy;
23	import org.eclipse.core.internal.net.ProxyData;	24	import org.eclipse.core.internal.net.ProxyData;
24	import org.eclipse.core.internal.net.StringMatcher;	25	import org.eclipse.core.internal.net.StringMatcher;
Lines 27-32 Link Here
27		28
28	public class UnixProxyProvider extends AbstractProxyProvider {	29	public class UnixProxyProvider extends AbstractProxyProvider {
29		30
		31	private static String NAME = "Native"; //$NON-NLS-1$
		32
30	private static final String LIBRARY_GCONF2 = "gconf-2"; //$NON-NLS-1$	33	private static final String LIBRARY_GCONF2 = "gconf-2"; //$NON-NLS-1$
31		34
32	private static final String LIBRARY_NAME = "gnomeproxy-1.0.0"; //$NON-NLS-1$	35	private static final String LIBRARY_NAME = "gnomeproxy-1.0.0"; //$NON-NLS-1$
Lines 49-54 Link Here
49	// Nothing to initialize	52	// Nothing to initialize
50	}	53	}
51		54
		55	public String getName() {
		56	return NAME;
		57	}
		58
		59	public String getLocalizedName() {
		60	return Messages.ProxySelector_2;
		61	}
		62
52	public IProxyData[] select(URI uri) {	63	public IProxyData[] select(URI uri) {
53	String[] nonProxyHosts = getNonProxiedHosts();	64	String[] nonProxyHosts = getNonProxiedHosts();
54	if (nonProxyHosts != null) {	65	if (nonProxyHosts != null) {




/*******************************************************************************
 * Copyright (c) 2007, 2010 IBM Corporation and others.
 * 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

	 * @param listener a change listener
	 */
	void removeProxyChangeListener(IProxyChangeListener listener);
	
	/**
	 * <p>
	 * Sets proxy provider that will be used to provide proxy data for methods:
	 * <li>{@link #select(URI)}</li>
	 * <li>{@link #getProxyDataForHost(String)}</li>
	 * <li>{@link #getProxyDataForHost(String, String)}</li>
	 * </p>
	 * <p>
	 * To use provider which was set using this method, 
	 * {@link #isProxiesEnabled()} and {@link #isSystemProxiesEnabled()}
	 * have to return <code>true</code>. Otherwise, value set by calling this method will be ignored. 
	 * </p>
	 * @param name - proxy provider's name. 
	 * To get all available providers call {@link #getAvailableProxyProviders()}
	 * @throws IllegalArgumentException - if there is no proxy provider with the given name
	 */
	void setProxyProvider(String name) throws IllegalArgumentException;
	
	/**
	 * Returns name of a current proxy provider which was set by calling {@link #setProxyProvider(String)}.
	 * This method returns:
	 * <li><code>Direct</code> - if {@link #isProxiesEnabled()} returns <code>false</code></li>
	 * <li><code>Manual</code> - if {@link #isProxiesEnabled()} returns <code>true</code> and {@link #isSystemProxiesEnabled()} returns <code>false</code></li>
	 * <li><code>Custom</code> - if {@link #isProxiesEnabled()} returns <code>true</code> and {@link #isSystemProxiesEnabled()} returns <code>true</code>, 
	 * where <code>Custom</code> is a provider set by calling {@link #setProxyProvider(String)}. 
	 * If there was no call to this method it returns <code>Native</code> provider. 
	 * If Native is unavailable, it returns <code>Direct</code>.</li>
	 * @return name of a current proxy provider
	 */
	String getProxyProvider();
	
	/**
	 * Returns all available proxy providers. Name is a unique identifier of each proxy provider.
	 * This method can be used to retrive providers which can be set using {@link #setProxyProvider(String)}
	 * New proxy provider can be added by extending org.eclipse.core.net.proxyProvider extension point.
	 * @return array of available providers names
	 */
	String[] getAvailableProxyProviders();
}

Lines 1-5 Link Here

(-)build.properties (-2 / +3 lines)
1	###############################################################################	1	###############################################################################
2	# Copyright (c) 2008 IBM Corporation and others.	2	# Copyright (c) 2008, 2010 IBM Corporation and others.
3	# All rights reserved. This program and the accompanying materials	3	# All rights reserved. This program and the accompanying materials
4	# are made available under the terms of the Eclipse Public License v1.0	4	# are made available under the terms of the Eclipse Public License v1.0
5	# which accompanies this distribution, and is available at	5	# which accompanies this distribution, and is available at
Lines 13-19 Link Here
13	about.html,\	13	about.html,\
14	META-INF/,\	14	META-INF/,\
15	bin/,\	15	bin/,\
16	jWinHttp-1.0.0.dll	16	jWinHttp-1.0.0.dll,\
		17	fragment.xml
17	generateSourceBundle=false	18	generateSourceBundle=false
18	src.includes = about.html	19	src.includes = about.html
19	source.. = src/	20	source.. = src/

Added Link Here

(-)fragment.xml (+11 lines)
1	<?xml version="1.0" encoding="UTF-8"?>
2	<?eclipse version="3.4"?>
3	<fragment>
4	<extension
5	point="org.eclipse.core.net.proxyProvider">
6	<proxyProvider
7	class="org.eclipse.core.internal.net.WindowsProxyProvider">
8	</proxyProvider>
9	</extension>
10
11	</fragment>




/*******************************************************************************
 * Copyright (c) 2008 compeople AG and others.
 * 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:
 * 	compeople AG (Stefan Liebig) - initial API and implementation
 *******************************************************************************/
package org.eclipse.core.net;

import org.eclipse.core.internal.net.WindowsProxyProvider;

public class ProxyProvider extends WindowsProxyProvider {
}

Lines 1-7 Link Here

(-)META-INF/MANIFEST.MF (-1 / +1 lines)
1	Manifest-Version: 1.0	1	Manifest-Version: 1.0
2	Bundle-ManifestVersion: 2	2	Bundle-ManifestVersion: 2
3	Bundle-Name: Net Tests Plug-in	3	Bundle-Name: Net Tests Plug-in
4	Bundle-SymbolicName: org.eclipse.core.tests.net	4	Bundle-SymbolicName: org.eclipse.core.tests.net;singleton:=true
5	Bundle-Version: 1.2.100.qualifier	5	Bundle-Version: 1.2.100.qualifier
6	Bundle-Activator: org.eclipse.core.tests.net.Activator	6	Bundle-Activator: org.eclipse.core.tests.net.Activator
7	Bundle-Vendor: Eclipse.org	7	Bundle-Vendor: Eclipse.org

Added Link Here

(-)plugin.xml (+11 lines)
1	<?xml version="1.0" encoding="UTF-8"?>
2	<?eclipse version="3.4"?>
3	<plugin>
4	<extension
5	point="org.eclipse.core.net.proxyProvider">
6	<proxyProvider
7	class="org.eclipse.core.tests.net.CustomProxyProvider">
8	</proxyProvider>
9	</extension>
10
11	</plugin>




/*******************************************************************************
 * Copyright (c) 2010 IBM Corporation and others.
 * 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:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
package org.eclipse.core.tests.net;

import java.net.URI;

import org.eclipse.core.internal.net.AbstractProxyProvider;
import org.eclipse.core.internal.net.ProxyData;
import org.eclipse.core.internal.net.StringMatcher;
import org.eclipse.core.net.proxy.IProxyData;

public class CustomProxyProvider extends AbstractProxyProvider {

	private static String NAME = "Test"; //$NON-NLS-1$
	
	private IProxyData[] proxies = {
			new ProxyData(IProxyData.HTTP_PROXY_TYPE, "customHttp", 1, false, NAME),
			new ProxyData(IProxyData.HTTPS_PROXY_TYPE, "customHttps", 2, false, NAME),
			new ProxyData(IProxyData.SOCKS_PROXY_TYPE, "customSocks", 3, false, NAME),
	};
	
	public String getName() {
		return NAME;
	}

	public String getLocalizedName() {
		return NAME;
	}
	
	public IProxyData[] select(URI uri) {
		String[] nonProxyHosts = getNonProxiedHosts();
		if (nonProxyHosts != null) {
			String host = uri.getHost();
			for (int npIndex = 0; npIndex < nonProxyHosts.length; npIndex++) {
				if (matchesFilter(host, nonProxyHosts[npIndex])) {
 					return new IProxyData[0];
 				}
			}
		}
		
		String scheme = uri.getScheme();
		if (scheme != null) {
			if (scheme.equalsIgnoreCase(IProxyData.HTTP_PROXY_TYPE)) {
				return new IProxyData[] { proxies[0] };
			}
			if (scheme.equalsIgnoreCase(IProxyData.HTTPS_PROXY_TYPE)) {
				return new IProxyData[] { proxies[1] };	
			}
			if (scheme.equalsIgnoreCase(IProxyData.SOCKS_PROXY_TYPE)) {
				return new IProxyData[] { proxies[2] };
			}
		}
		return proxies;
	}

	protected IProxyData[] getProxyData() {
		return proxies;
	}

	protected String[] getNonProxiedHosts() {
		return new String[] { "customBypass" };
	}
	
	private boolean matchesFilter(String host, String filter) {
		StringMatcher matcher = new StringMatcher(filter, true, false);
		return matcher.match(host);
	}

}




import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Properties;



		this.getProxyManager().setNonProxiedHosts(oldHosts);
	}
	
	public void testCustomProxyProvider() {
		List providers = Arrays.asList(getProxyManager().getAvailableProxyProviders());
		assertEquals(4, providers.size());
		assertTrue(providers.contains("Direct"));
		assertTrue(providers.contains("Manual"));
		assertTrue(providers.contains("Native"));
		assertTrue(providers.contains("Test"));
	}
	
	public void testSetCustomProxyProvider() throws CoreException {
		setDataTest(IProxyData.HTTP_PROXY_TYPE);
		setDataTest(IProxyData.HTTPS_PROXY_TYPE);
		setDataTest(IProxyData.SOCKS_PROXY_TYPE);
		
		IProxyService service = getProxyManager();
		service.setProxyProvider("Test");
		
		setSystemProxiesEnabled(false);
		setProxiesEnabled(false);
		assertEquals("Direct", service.getProxyProvider());
		validateSystemProperties(false);
		
		setSystemProxiesEnabled(false);
		setProxiesEnabled(true);
		assertEquals("Manual", service.getProxyProvider());
		validateSystemProperties(true);
		
		setSystemProxiesEnabled(true);
		setProxiesEnabled(true);
		assertEquals("Test", service.getProxyProvider());
		
		setSystemProxiesEnabled(false);
		setProxiesEnabled(false);
		assertEquals("Direct", service.getProxyProvider());
		validateSystemProperties(false);
	}
	
	public void testSelectCustomProxyProvider() throws CoreException, URISyntaxException {	
		IProxyService service = getProxyManager();
		service.setProxyProvider("Test");
		setSystemProxiesEnabled(true);
		
		IProxyData[] proxies = service.select(new URI("eclipse.org"));
		assertEquals(3, proxies.length);
		
		IProxyData[] httpProxy = service.select(new URI("http://eclipse.org"));
		assertEquals(1, httpProxy.length);
		assertEquals(proxies[0], httpProxy[0]);
		
		IProxyData[] httpsProxy = service.select(new URI("https://eclipse.org"));
		assertEquals(1, httpsProxy.length);
		assertEquals(proxies[1], httpsProxy[0]);
		
		IProxyData[] socksProxy = service.select(new URI("socks://eclipse.org"));
		assertEquals(1, socksProxy.length);
		assertEquals(proxies[2], socksProxy[0]);
	}
	
	public void testChangeCustomProxyProvider() throws CoreException, URISyntaxException {	
		IProxyService service = getProxyManager();
		service.setProxyProvider("Test");
		setSystemProxiesEnabled(true);
		
		IProxyData[] proxies = service.select(new URI("eclipse.org"));
		assertEquals(3, proxies.length);
		
		service.setProxyProvider("Native");
		proxies = service.select(new URI("eclipse.org"));
		assertEquals(0, proxies.length);
	}
	
	public void testBypassProxyProvider() throws CoreException, URISyntaxException {	
		IProxyService service = getProxyManager();
		service.setProxyProvider("Test");
		setSystemProxiesEnabled(true);
		
		IProxyData[] proxies = service.select(new URI("customBypass"));
		assertEquals(0, proxies.length);
		
		IProxyData[] httpProxy = service.select(new URI("http://customBypass"));
		assertEquals(0, httpProxy.length);
		
		IProxyData[] httpsProxy = service.select(new URI("https://customBypass"));
		assertEquals(0, httpsProxy.length);
		
		IProxyData[] socksProxy = service.select(new URI("socks://customBypass"));
		assertEquals(0, socksProxy.length);
	}

	private void validateSystemProperties(boolean present) {
		validateProperty("http.proxySet", "true", present);

Return to bug 257443

Lines 15-20 Link Here

(-)src/org/eclipse/core/tests/net/NetTest.java (+90 lines)
15	import java.util.ArrayList;	15	import java.util.ArrayList;
16	import java.util.Arrays;	16	import java.util.Arrays;
17	import java.util.HashMap;	17	import java.util.HashMap;
		18	import java.util.List;
18	import java.util.Map;	19	import java.util.Map;
19	import java.util.Properties;	20	import java.util.Properties;
20		21
Lines 431-436 Link Here
431		432
432	this.getProxyManager().setNonProxiedHosts(oldHosts);	433	this.getProxyManager().setNonProxiedHosts(oldHosts);
433	}	434	}
		435
		436	public void testCustomProxyProvider() {
		437	List providers = Arrays.asList(getProxyManager().getAvailableProxyProviders());
		438	assertEquals(4, providers.size());
		439	assertTrue(providers.contains("Direct"));
		440	assertTrue(providers.contains("Manual"));
		441	assertTrue(providers.contains("Native"));
		442	assertTrue(providers.contains("Test"));
		443	}
		444
		445	public void testSetCustomProxyProvider() throws CoreException {
		446	setDataTest(IProxyData.HTTP_PROXY_TYPE);
		447	setDataTest(IProxyData.HTTPS_PROXY_TYPE);
		448	setDataTest(IProxyData.SOCKS_PROXY_TYPE);
		449
		450	IProxyService service = getProxyManager();
		451	service.setProxyProvider("Test");
		452
		453	setSystemProxiesEnabled(false);
		454	setProxiesEnabled(false);
		455	assertEquals("Direct", service.getProxyProvider());
		456	validateSystemProperties(false);
		457
		458	setSystemProxiesEnabled(false);
		459	setProxiesEnabled(true);
		460	assertEquals("Manual", service.getProxyProvider());
		461	validateSystemProperties(true);
		462
		463	setSystemProxiesEnabled(true);
		464	setProxiesEnabled(true);
		465	assertEquals("Test", service.getProxyProvider());
		466
		467	setSystemProxiesEnabled(false);
		468	setProxiesEnabled(false);
		469	assertEquals("Direct", service.getProxyProvider());
		470	validateSystemProperties(false);
		471	}
		472
		473	public void testSelectCustomProxyProvider() throws CoreException, URISyntaxException {
		474	IProxyService service = getProxyManager();
		475	service.setProxyProvider("Test");
		476	setSystemProxiesEnabled(true);
		477
		478	IProxyData[] proxies = service.select(new URI("eclipse.org"));
		479	assertEquals(3, proxies.length);
		480
		481	IProxyData[] httpProxy = service.select(new URI("http://eclipse.org"));
		482	assertEquals(1, httpProxy.length);
		483	assertEquals(proxies[0], httpProxy[0]);
		484
		485	IProxyData[] httpsProxy = service.select(new URI("https://eclipse.org"));
		486	assertEquals(1, httpsProxy.length);
		487	assertEquals(proxies[1], httpsProxy[0]);
		488
		489	IProxyData[] socksProxy = service.select(new URI("socks://eclipse.org"));
		490	assertEquals(1, socksProxy.length);
		491	assertEquals(proxies[2], socksProxy[0]);
		492	}
		493
		494	public void testChangeCustomProxyProvider() throws CoreException, URISyntaxException {
		495	IProxyService service = getProxyManager();
		496	service.setProxyProvider("Test");
		497	setSystemProxiesEnabled(true);
		498
499	IProxyData[] proxies = service.select(new URI("eclipse.org"));
500	assertEquals(3, proxies.length);
501
502	service.setProxyProvider("Native");
503	proxies = service.select(new URI("eclipse.org"));
504	assertEquals(0, proxies.length);
505	}
506
507	public void testBypassProxyProvider() throws CoreException, URISyntaxException {
508	IProxyService service = getProxyManager();
509	service.setProxyProvider("Test");
510	setSystemProxiesEnabled(true);
511
512	IProxyData[] proxies = service.select(new URI("customBypass"));
513	assertEquals(0, proxies.length);
514
515	IProxyData[] httpProxy = service.select(new URI("http://customBypass"));
516	assertEquals(0, httpProxy.length);
517
518	IProxyData[] httpsProxy = service.select(new URI("https://customBypass"));
519	assertEquals(0, httpsProxy.length);
520
521	IProxyData[] socksProxy = service.select(new URI("socks://customBypass"));
522	assertEquals(0, socksProxy.length);
523	}
434		524
435	private void validateSystemProperties(boolean present) {	525	private void validateSystemProperties(boolean present) {
436	validateProperty("http.proxySet", "true", present);	526	validateProperty("http.proxySet", "true", present);

Added Link Here

(-)schema/proxyProvider.exsd (+102 lines)
1	<?xml version='1.0' encoding='UTF-8'?>
2	<!-- Schema file written by PDE -->
3	<schema targetNamespace="org.eclipse.core.net" xmlns="http://www.w3.org/2001/XMLSchema">
4	<annotation>
5	<appInfo>
6	<meta.schema plugin="org.eclipse.core.net" id="proxyProvider" name="ProxyProvider"/>
7	</appInfo>
8	<documentation>
9	[Enter description of this extension point.]
10	</documentation>
11	</annotation>
12
13	<element name="extension">
14	<annotation>
15	<appInfo>
16	<meta.element />
17	</appInfo>
18	</annotation>
19	<complexType>
20	<sequence>
21	<element ref="proxyProvider" minOccurs="1" maxOccurs="unbounded"/>
22	</sequence>
23	<attribute name="point" type="string" use="required">
24	<annotation>
25	<documentation>
26
27	</documentation>
28	</annotation>
29	</attribute>
30	<attribute name="id" type="string">
31	<annotation>
32	<documentation>
33
34	</documentation>
35	</annotation>
36	</attribute>
37	<attribute name="name" type="string">
38	<annotation>
39	<documentation>
40
41	</documentation>
42	<appInfo>
43	<meta.attribute translatable="true"/>
44	</appInfo>
45	</annotation>
46	</attribute>
47	</complexType>
48	</element>
49
50	<element name="proxyProvider">
51	<complexType>
52	<attribute name="class" type="string" use="required">
53	<annotation>
54	<documentation>
55
56	</documentation>
57	<appInfo>
58	<meta.attribute kind="java" basedOn="org.eclipse.core.internal.net.AbstractProxyProvider:"/>
59	</appInfo>
60	</annotation>
61	</attribute>
62	</complexType>
63	</element>
64
65	<annotation>
66	<appInfo>
67	<meta.section type="since"/>
68	</appInfo>
69	<documentation>
70	[Enter the first release in which this extension point appears.]
71	</documentation>
72	</annotation>
73
74	<annotation>
75	<appInfo>
76	<meta.section type="examples"/>
77	</appInfo>
78	<documentation>
79	[Enter extension point usage example here.]
80	</documentation>
81	</annotation>
82
83	<annotation>
84	<appInfo>
85	<meta.section type="apiinfo"/>
86	</appInfo>
87	<documentation>
88	[Enter API information here.]
89	</documentation>
90	</annotation>
91
92	<annotation>
93	<appInfo>
94	<meta.section type="implementation"/>
95	</appInfo>
96	<documentation>
97	[Enter information about supplied implementation of this extension point.]
98	</documentation>
99	</annotation>
100
101
102	</schema>

Added Link Here

(-)src/org/eclipse/core/internal/net/proxy/DirectProxyProvider.java (+43 lines)
1	/*******************************************************************************
2	* Copyright (c) 2010 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* IBM Corporation - initial API and implementation
10	*******************************************************************************/
11	package org.eclipse.core.internal.net.proxy;
12
13	import java.net.URI;
14
15	import org.eclipse.core.internal.net.AbstractProxyProvider;
16	import org.eclipse.core.internal.net.Messages;
17	import org.eclipse.core.net.proxy.IProxyData;
18
19	public class DirectProxyProvider extends AbstractProxyProvider {
20
21	private static String NAME = "Direct"; //$NON-NLS-1$
22
23	public String getName() {
24	return NAME;
25	}
26
27	public String getLocalizedName() {
28	return Messages.ProxySelector_0;
29	}
30
31	public IProxyData[] select(URI uri) {
32	return new IProxyData[0];
33	}
34
35	protected IProxyData[] getProxyData() {
36	return new IProxyData[0];
37	}
38
39	protected String[] getNonProxiedHosts() {
40	return new String[0];
41	}
42
43	}

Lines 1-5 Link Here

(-)src/org/eclipse/core/net/proxy/IProxyService.java (-1 / +40 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright (c) 2007, 2008 IBM Corporation and others.	2	* Copyright (c) 2007, 2010 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials	3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0	4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at	5	* which accompanies this distribution, and is available at
Lines 260-263 Link Here
260	* @param listener a change listener	260	* @param listener a change listener
261	*/	261	*/
262	void removeProxyChangeListener(IProxyChangeListener listener);	262	void removeProxyChangeListener(IProxyChangeListener listener);
		263
		264	/**
		265	* <p>
		266	* Sets proxy provider that will be used to provide proxy data for methods:
		267	* <li>{@link #select(URI)}</li>
		268	* <li>{@link #getProxyDataForHost(String)}</li>
		269	* <li>{@link #getProxyDataForHost(String, String)}</li>
		270	* </p>
		271	* <p>
		272	* To use provider which was set using this method,
		273	* {@link #isProxiesEnabled()} and {@link #isSystemProxiesEnabled()}
		274	* have to return <code>true</code>. Otherwise, value set by calling this method will be ignored.
		275	* </p>
		276	* @param name - proxy provider's name.
		277	* To get all available providers call {@link #getAvailableProxyProviders()}
		278	* @throws IllegalArgumentException - if there is no proxy provider with the given name
		279	*/
		280	void setProxyProvider(String name) throws IllegalArgumentException;
		281
		282	/**
		283	* Returns name of a current proxy provider which was set by calling {@link #setProxyProvider(String)}.
		284	* This method returns:
		285	* <li><code>Direct</code> - if {@link #isProxiesEnabled()} returns <code>false</code></li>
		286	* <li><code>Manual</code> - if {@link #isProxiesEnabled()} returns <code>true</code> and {@link #isSystemProxiesEnabled()} returns <code>false</code></li>
		287	* <li><code>Custom</code> - if {@link #isProxiesEnabled()} returns <code>true</code> and {@link #isSystemProxiesEnabled()} returns <code>true</code>,
		288	* where <code>Custom</code> is a provider set by calling {@link #setProxyProvider(String)}.
		289	* If there was no call to this method it returns <code>Native</code> provider.
		290	* If Native is unavailable, it returns <code>Direct</code>.</li>
		291	* @return name of a current proxy provider
		292	*/
		293	String getProxyProvider();
		294
		295	/**
		296	* Returns all available proxy providers. Name is a unique identifier of each proxy provider.
		297	* This method can be used to retrive providers which can be set using {@link #setProxyProvider(String)}
		298	* New proxy provider can be added by extending org.eclipse.core.net.proxyProvider extension point.
		299	* @return array of available providers names
		300	*/
		301	String[] getAvailableProxyProviders();
263	}	302	}

Removed Link Here

(-)src/org/eclipse/core/net/ProxyProvider.java (-16 lines)
1	/*******************************************************************************
2	* Copyright (c) 2008 compeople AG and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* compeople AG (Stefan Liebig) - initial API and implementation
10	*******************************************************************************/
11	package org.eclipse.core.net;
12
13	import org.eclipse.core.internal.net.WindowsProxyProvider;
14
15	public class ProxyProvider extends WindowsProxyProvider {
16	}

Added Link Here

(-)src/org/eclipse/core/tests/net/CustomProxyProvider.java (+77 lines)
1	/*******************************************************************************
2	* Copyright (c) 2010 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* IBM Corporation - initial API and implementation
10	*******************************************************************************/
11	package org.eclipse.core.tests.net;
12
13	import java.net.URI;
14
15	import org.eclipse.core.internal.net.AbstractProxyProvider;
16	import org.eclipse.core.internal.net.ProxyData;
17	import org.eclipse.core.internal.net.StringMatcher;
18	import org.eclipse.core.net.proxy.IProxyData;
19
20	public class CustomProxyProvider extends AbstractProxyProvider {
21
22	private static String NAME = "Test"; //$NON-NLS-1$
23
24	private IProxyData[] proxies = {
25	new ProxyData(IProxyData.HTTP_PROXY_TYPE, "customHttp", 1, false, NAME),
26	new ProxyData(IProxyData.HTTPS_PROXY_TYPE, "customHttps", 2, false, NAME),
27	new ProxyData(IProxyData.SOCKS_PROXY_TYPE, "customSocks", 3, false, NAME),
28	};
29
30	public String getName() {
31	return NAME;
32	}
33
34	public String getLocalizedName() {
35	return NAME;
36	}
37
38	public IProxyData[] select(URI uri) {
39	String[] nonProxyHosts = getNonProxiedHosts();
40	if (nonProxyHosts != null) {
41	String host = uri.getHost();
42	for (int npIndex = 0; npIndex < nonProxyHosts.length; npIndex++) {
43	if (matchesFilter(host, nonProxyHosts[npIndex])) {
44	return new IProxyData[0];
45	}
46	}
47	}
48
49	String scheme = uri.getScheme();
50	if (scheme != null) {
51	if (scheme.equalsIgnoreCase(IProxyData.HTTP_PROXY_TYPE)) {
52	return new IProxyData[] { proxies[0] };
53	}
54	if (scheme.equalsIgnoreCase(IProxyData.HTTPS_PROXY_TYPE)) {
55	return new IProxyData[] { proxies[1] };
56	}
57	if (scheme.equalsIgnoreCase(IProxyData.SOCKS_PROXY_TYPE)) {
58	return new IProxyData[] { proxies[2] };
59	}
60	}
61	return proxies;
62	}
63
64	protected IProxyData[] getProxyData() {
65	return proxies;
66	}
67
68	protected String[] getNonProxiedHosts() {
69	return new String[] { "customBypass" };
70	}
71
72	private boolean matchesFilter(String host, String filter) {
73	StringMatcher matcher = new StringMatcher(filter, true, false);
74	return matcher.match(host);
75	}
76
77	}