/*******************************************************************************
* Copyright (c) 2002-2005 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 - Initial API and implementation
*******************************************************************************/
package org.eclipse.wst.wsi.internal.core.monitor;
import java.net.Socket;
import java.util.Iterator;
import java.util.Vector;
import org.eclipse.wst.wsi.internal.core.WSIException;
import org.eclipse.wst.wsi.internal.core.log.MessageEntry;
import org.eclipse.wst.wsi.internal.core.log.MimeParts;
import org.eclipse.wst.wsi.internal.core.monitor.config.Redirect;
import org.eclipse.wst.wsi.internal.core.util.Utils;
/**
* A socket connection.
*
* @author Peter Brittenham (peterbr@us.ibm.com)
* @version 1.0.1
*/
public class SocketConnection extends Thread
{
protected Monitor monitor;
protected Redirect redirect;
protected Socket inSocket;
protected Socket outSocket;
protected String httpProxyHost = null;
protected int httpProxyPort;
protected SocketHandler requestSocketHandler = null;
protected SocketHandler responseSocketHandler = null;
private Vector listeners = new Vector(); // SS
/**
* Create socket connection.
* @param monitor a Monitor object.
* @param redirect a Redirect object.
* @param inSocket in socket.
*/
public SocketConnection(Monitor monitor, Redirect redirect, Socket inSocket)
{
this.monitor = monitor;
this.redirect = redirect;
this.inSocket = inSocket;
// Start processing the connection
start();
}
/**
* Process the socket connection.
*/
public void run()
{
// Get the HTTP proxy settings if there are any set (not used currently)
loadHttpProxySettings();
try
{
// Open the connection to the server
this.outSocket = new Socket(redirect.getToHost(), redirect.getToPort());
// Set the read timeout for the input socket
this.inSocket.setSoTimeout(redirect.getReadTimeoutSeconds() * 1000);
// Get the next conversation ID
int conversationId = monitor.getNextConversationId();
// Create the socket handlers which are used to send the data from
// the client to the server
requestSocketHandler =
new SocketHandler(
this,
MessageEntry.TYPE_REQUEST,
conversationId,
redirect.getToHost(),
this.inSocket,
this.outSocket,
redirect.getReadTimeoutSeconds());
responseSocketHandler =
new SocketHandler(
this,
MessageEntry.TYPE_RESPONSE,
conversationId,
redirect.getToHost(),
this.outSocket,
this.inSocket,
redirect.getReadTimeoutSeconds());
// Tell each socketHandler about the other one
requestSocketHandler.setPairedSocketHandler(responseSocketHandler);
responseSocketHandler.setPairedSocketHandler(requestSocketHandler);
}
catch (Exception e)
{
Monitor.staticPrintMessage(
"error04",
redirect.getToHost(),
"Monitor cannot connect to a redirect host:");
shutdown();
try
{
this.inSocket.close();
}
catch (Throwable t)
{
}
}
}
/**
* Log message.
* @param conversationID the coversation id.
* @param connectionType the connection type.
* @param timestamp the timestamp.
* @param senderHostAndPort the sender host and port.
* @param receiverHostAndPort the receiver host and port.
* @param messageBuffer the message.
* @param bom the BOM.
* @param encoding the encoding.
* @throws WSIException if there is a problem logging message.
*/
public void logMessage(
int conversationID,
String connectionType,
String timestamp,
String senderHostAndPort,
String receiverHostAndPort,
StringBuffer messageBuffer,
int bom,
String encoding)
throws WSIException
{
MessageEntry messageEntry = null;
// Create message entry
messageEntry =
createMessageEntry(
conversationID,
connectionType,
timestamp,
senderHostAndPort,
receiverHostAndPort,
messageBuffer.toString(),
bom,
encoding);
// DEBUG:
//debug("logMessage", " messageEntry: " + messageEntry);
// Add entry to the queue
monitor.getMessageEntryQueue().addMessageEntry(messageEntry);
}
/**
* Create a log entry from all of the data that was gathered.
*/
private MessageEntry createMessageEntry(
int conversationID,
String messageType,
String timestamp,
String senderHostAndPort,
String receiverHostAndPort,
String message,
int bom,
String encoding)
throws WSIException
{
// Create log entry object
MessageEntry messageEntry = monitor.getLog().createLogEntry();
// Set input information in log entry
// NOTE: The ID is set just before the log entry is written to the log file in LogEntryQueue
//logEntry.setId(id);
messageEntry.setConversationId(String.valueOf(conversationID));
messageEntry.setType(messageType);
messageEntry.setTimestamp(timestamp);
messageEntry.setSenderHostAndPort(senderHostAndPort);
messageEntry.setReceiverHostAndPort(receiverHostAndPort);
messageEntry.setEncoding(encoding);
// Get HTTP headers from full message
String httpHeaders = Utils.getHTTPHeaders(message);
messageEntry.setHTTPHeaders(httpHeaders);
if (Utils.isMultipartRelatedMessage(httpHeaders))
{
MimeParts mimeParts = Utils.parseMultipartRelatedMessage(message, httpHeaders, encoding);
if (mimeParts == null)
{
// problem creating Mimeparts -- treat it as simple SOAP message
String content = Utils.getContent(message);
messageEntry.setMessage(content);
messageEntry.setMimeContent(false);
}
else
{
messageEntry.setMimeParts(mimeParts);
messageEntry.setMimeContent(true);
}
}
else
{
// Get the message content
String content = Utils.getContent(message);
messageEntry.setMessage(content);
messageEntry.setMimeContent(false);
}
// Set the BOM, if there is one
if (bom != 0)
messageEntry.setBOM(bom);
return messageEntry;
}
/**
* Load HTTP proxy settings.
*/
public void loadHttpProxySettings()
{
// Get the HTTP proxy host setting
this.httpProxyHost = System.getProperty("http.proxyHost");
if (this.httpProxyHost != null && httpProxyHost.equals(""))
this.httpProxyHost = null;
// If there was an HTTP proxy host setting, then get the port
if (this.httpProxyHost != null)
{
String portString = System.getProperty("http.proxyPort");
// Set default to 80
if (portString == null || portString.equals(""))
this.httpProxyPort = 80;
else
httpProxyPort = Integer.parseInt(portString);
}
}
Monitor getMonitor()
{
return this.monitor;
}
synchronized void wakeUp()
{
fireConnectionClosed(); // SS
notifyAll();
}
/**
* Shutdown.
*/
public void shutdown()
{
if (this.requestSocketHandler != null)
this.requestSocketHandler.shutdown();
if (this.responseSocketHandler != null)
this.responseSocketHandler.shutdown();
}
// ==== SS start ====
/**
* Add connection event listener.
* @param listener event listener.
* @see #removeConnectionListener
*/
public void addConnectionListener(ConnectionListener listener)
{
listeners.add(listener);
}
/**
* Remove connection event listener.
* @param listener event listener.
* @see #addConnectionListener
*/
public void removeConnectionListener(ConnectionListener listener)
{
listeners.remove(listener);
}
/**
* Notify listeners on connection close.
*/
private void fireConnectionClosed()
{
for (Iterator i = listeners.iterator(); i.hasNext();)
{
ConnectionListener listener = (ConnectionListener) i.next();
listener.connectionClosed(this);
}
}
// ==== SS end ====
}