package com.sonatype.buildserver.monitor;
import java.net.URI;
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
import java.util.UUID;
import org.eclipse.core.net.proxy.IProxyData;
import org.eclipse.core.net.proxy.IProxyService;
import org.eclipse.core.runtime.preferences.IEclipsePreferences;
import org.eclipse.core.runtime.preferences.InstanceScope;
import org.maven.ide.eclipse.authentication.AuthFacade;
import org.maven.ide.eclipse.authentication.IAuthData;
import org.osgi.service.prefs.BackingStoreException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import com.sonatype.buildserver.eclipse.ui.HudsonUIActivator;
import com.sonatype.buildserver.hudsonclient.HudsonRestFactory;
import org.hudsonci.rest.client.HudsonClient;
import org.hudsonci.rest.client.OpenOptions;
{
private static final Map<URI, HudsonClient> serverConnections =
Collections.synchronizedMap( new HashMap<URI, HudsonClient>() );
private static final Map<String, HudsonMonitor> monitors = Collections.synchronizedMap( new HashMap<String, HudsonMonitor>() );
private static final Map<String, CompositeMonitor> composites = Collections.synchronizedMap( new HashMap<String, CompositeMonitor>() );
private static Logger log = LoggerFactory.getLogger( HudsonManager.class );
{
synchronized ( serverConnections )
{
HudsonClient client = serverConnections.get( server );
if ( client == null )
{
client = createClient(server);
} else {
IAuthData data = AuthFacade.getAuthService().select( server.toString() );
OpenOptions op = client.getOptions();
boolean changed;
if (data != null) {
String persistedUser = data.getUsername() == null || data.getUsername().length() == 0 ? null : data.getUsername();
String persistedPass = data.getPassword() == null || data.getPassword().length() == 0 ? null : data.getPassword();
changed = changed(persistedUser, op.getUsername()) || changed(persistedPass, op.getPassword());
} else {
changed = op.getPassword() != null || op.getUsername() != null;
}
if (changed) {
client.close();
resetServer(server);
client = createClient(server);
}
}
return client;
}
}
HudsonClient client = HudsonRestFactory.getClient();
IAuthData data = AuthFacade.getAuthService().select( server.toString() );
OpenOptions options = new OpenOptions();
options.setDisableCertificateValidation( true );
if ( data != null )
{
setAuthentication(data, options);
}
IProxyData proxyInfo = selectProxy(server, HudsonUIActivator.getDefault().getProxyService());
if ( proxyInfo != null && proxyInfo.getHost() != null )
{
options.setProxyHost( proxyInfo.getHost() );
options.setProxyPort( proxyInfo.getPort() );
options.setProxyProtocol( proxyInfo.getType() );
if ( proxyInfo.isRequiresAuthentication() )
{
options.setProxyUsername( proxyInfo.getUserId() );
options.setProxyPassword( proxyInfo.getPassword() );
log.debug( "Connecting to {} via proxy {} and authentication", server, options.getProxyHost() );
}
else
{
log.debug( "Connecting to {} via proxy {} and no authentication", server, options.getProxyHost() );
}
}
else
{
log.debug( "Connecting to {} without proxy", server );
}
client.open( server, options );
serverConnections.put( server, client );
return client;
}
private static boolean changed(String newStr, String oldStr) {
return newStr == null && oldStr != null || (newStr != null && !newStr.equals(oldStr));
}
String login = data.getUsername();
String pwd = data.getPassword();
if ( login != null && login.length() > 0 )
{
options.setUsername( login );
options.setPassword( pwd );
} else {
options.setUsername(null);
options.setPassword(null);
}
}
{
synchronized ( serverConnections )
{
serverConnections.remove( serverURI );
}
}
if (uuid != null) {
synchronized ( monitors )
{
HudsonMonitor bm = monitors.get( uuid );
if (bm != null) {
return bm;
}
}
}
HudsonMonitorSesame open = new HudsonMonitorSesame( uri, uuid );
HudsonMonitor bm = new HudsonMonitor( open );
monitors.put( bm.getId().toString(), bm );
return bm;
}
{
if ( m == null )
return null;
synchronized ( composites )
{
if ( !composites.containsKey( m.getId().toString() ) )
{
composites.put(m.getId().toString(), m );
return m;
}
else
{
return composites.get( m.getId().toString() );
}
}
}
{
synchronized ( composites )
{
CompositeMonitor monitor = composites.get( monitorId );
if ( monitor != null )
return monitor;
Object loaded = MonitorPersistence.load( monitorId );
if (! (loaded instanceof CompositeMonitor)) {
throw new IllegalStateException("Wrong type of monitor loaded for " + monitorId);
}
monitor = (CompositeMonitor)loaded;
monitor.populateProvidedJobs( false );
monitor.refreshAll();
return addCompositeMonitor( monitor );
}
}
public static void setClient( URI uri, HudsonClient client ) {
synchronized ( serverConnections )
{
serverConnections.put( uri, client );
}
}
{
IEclipsePreferences pref = new InstanceScope().getNode( HudsonUIActivator.PLUGIN_ID );
String id = pref.get( "defaultMonitor", null );
if ( id != null )
{
CompositeMonitor o = HudsonManager.getCompositeMonitor( id );
if ( o != null )
return o;
}
CompositeMonitor createdMonitor = new CompositeMonitor();
pref.put( "defaultMonitor", createdMonitor.getId().toString() );
try
{
pref.flush();
}
catch ( BackingStoreException e )
{
log.debug( "Error while storing default monitor UUID.", e );
return createdMonitor;
}
createdMonitor.save();
return HudsonManager.getCompositeMonitor( createdMonitor.getId().toString() );
}
private static IProxyData
selectProxy( URI url, IProxyService proxyService )
{
if ( proxyService != null && proxyService.isProxiesEnabled() )
{
IProxyData[] proxies = proxyService.select( url );
if ( proxies.length > 0 )
{
if ( proxies.length == 1 )
{
return proxies[0];
}
else
{
String protocol = url.getScheme();
for ( IProxyData proxy : proxies )
{
if ( protocol.equalsIgnoreCase( proxy.getType() ) )
{
return proxy;
}
}
return proxies[0];
}
}
}
return null;
}
final URI uri;
final UUID uuid;
this.uri = uri;
this.uuid = uuid;
}
}
}