axis-java-dev mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From d...@apache.org
Subject svn commit: r289655 [1/2] - in /webservices/axis2/trunk/java/modules: core/src/org/apache/axis2/util/ tool/src/org/apache/axis2/tool/tracer/
Date Fri, 16 Sep 2005 21:30:35 GMT
Author: dims
Date: Fri Sep 16 14:30:29 2005
New Revision: 289655

URL: http://svn.apache.org/viewcvs?rev=289655&view=rev
Log:
tcpmon should not be in core, it is a tool. Hence morphing tcpmon to HTTPTracer (courtesy of stefano - http://simile.mit.edu/httptracer/index.html). 

Here's some additional info from Stefano.
===========================================================================
Davanum Srinivas wrote:
> Hi Stefano,
>
> Can we "borrow" the code back? We're cutting Axis 1.3 and sounds like
> a good thing to update tcpmon :)

Absolutely. I just added a few minor things:

 1) refactored a little (to avoid having 20 classes in one file)

 2) change the name (tcpmon is misleading, IMO)

 3) added the build file and all that stuff

 4) added timing of responses (that needs work).

the code is still licensed under the AL 2.0, so do whatever you want
with it :-)

> -- dims
>
> PS: FYI, despite your ample warnings, i quit my day job and am knee
> deep in web services (http://wso2.com)

Well, good luck :-)
===========================================================================

--
Stefano.


Added:
    webservices/axis2/trunk/java/modules/tool/src/org/apache/axis2/tool/tracer/
    webservices/axis2/trunk/java/modules/tool/src/org/apache/axis2/tool/tracer/AdminPane.java
    webservices/axis2/trunk/java/modules/tool/src/org/apache/axis2/tool/tracer/Connection.java
    webservices/axis2/trunk/java/modules/tool/src/org/apache/axis2/tool/tracer/HTTPTracer.java
    webservices/axis2/trunk/java/modules/tool/src/org/apache/axis2/tool/tracer/Listener.java
    webservices/axis2/trunk/java/modules/tool/src/org/apache/axis2/tool/tracer/SlowLinkSimulator.java
    webservices/axis2/trunk/java/modules/tool/src/org/apache/axis2/tool/tracer/SocketRR.java
    webservices/axis2/trunk/java/modules/tool/src/org/apache/axis2/tool/tracer/SocketWaiter.java
    webservices/axis2/trunk/java/modules/tool/src/org/apache/axis2/tool/tracer/httptracer.properties
Removed:
    webservices/axis2/trunk/java/modules/core/src/org/apache/axis2/util/tcpmon.java
    webservices/axis2/trunk/java/modules/core/src/org/apache/axis2/util/tcpmon.properties

Added: webservices/axis2/trunk/java/modules/tool/src/org/apache/axis2/tool/tracer/AdminPane.java
URL: http://svn.apache.org/viewcvs/webservices/axis2/trunk/java/modules/tool/src/org/apache/axis2/tool/tracer/AdminPane.java?rev=289655&view=auto
==============================================================================
--- webservices/axis2/trunk/java/modules/tool/src/org/apache/axis2/tool/tracer/AdminPane.java (added)
+++ webservices/axis2/trunk/java/modules/tool/src/org/apache/axis2/tool/tracer/AdminPane.java Fri Sep 16 14:30:29 2005
@@ -0,0 +1,625 @@
+/*
+ * Copyright 2004,2005 The Apache Software Foundation.
+ *
+ * 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.apache.axis2.tool.tracer;
+
+import javax.swing.Box;
+import javax.swing.ButtonGroup;
+import javax.swing.JButton;
+import javax.swing.JCheckBox;
+import javax.swing.JLabel;
+import javax.swing.JPanel;
+import javax.swing.JRadioButton;
+import javax.swing.JScrollPane;
+import javax.swing.JTabbedPane;
+import javax.swing.JTextField;
+import javax.swing.border.TitledBorder;
+import javax.swing.text.AttributeSet;
+import javax.swing.text.BadLocationException;
+import javax.swing.text.Document;
+import javax.swing.text.PlainDocument;
+import java.awt.BorderLayout;
+import java.awt.Color;
+import java.awt.Dimension;
+import java.awt.GridBagConstraints;
+import java.awt.GridBagLayout;
+import java.awt.event.ActionEvent;
+import java.awt.event.ActionListener;
+
+/**
+ * this is the admin page
+ */
+class AdminPane extends JPanel {
+	
+    /**
+     * Field listenerButton, proxyButton
+     */
+    public JRadioButton listenerButton, proxyButton;
+
+    /**
+     * Field hostLabel, tportLabel
+     */
+    public JLabel hostLabel, tportLabel;
+
+    /**
+     * Field port
+     */
+    public NumberField port;
+
+    /**
+     * Field host
+     */
+    public HostnameField host;
+
+    /**
+     * Field tport
+     */
+    public NumberField tport;
+
+    /**
+     * Field noteb
+     */
+    public JTabbedPane noteb;
+
+    /**
+     * Field HTTPProxyBox
+     */
+    public JCheckBox HTTPProxyBox;
+
+    /**
+     * Field HTTPProxyHost
+     */
+    public HostnameField HTTPProxyHost;
+
+    /**
+     * Field HTTPProxyPort
+     */
+    public NumberField HTTPProxyPort;
+
+    /**
+     * Field HTTPProxyHostLabel, HTTPProxyPortLabel
+     */
+    public JLabel HTTPProxyHostLabel, HTTPProxyPortLabel;
+
+    /**
+     * Field delayTimeLabel, delayBytesLabel
+     */
+    public JLabel delayTimeLabel, delayBytesLabel;
+
+    /**
+     * Field delayTime, delayBytes
+     */
+    public NumberField delayTime, delayBytes;
+
+    /**
+     * Field delayBox
+     */
+    public JCheckBox delayBox;
+
+    /**
+     * Constructor AdminPage
+     *
+     * @param notebook
+     * @param name
+     */
+    public AdminPane(JTabbedPane notebook, String name) {
+        JPanel mainPane = null;
+        JButton addButton = null;
+        this.setLayout(new BorderLayout());
+        noteb = notebook;
+        GridBagLayout layout = new GridBagLayout();
+        GridBagConstraints c = new GridBagConstraints();
+        mainPane = new JPanel(layout);
+        c.anchor = GridBagConstraints.WEST;
+        c.gridwidth = GridBagConstraints.REMAINDER;
+        mainPane.add(new JLabel(HTTPTracer.getMessage("newTCP00",
+                "Create a new HTTP tracer...")
+                + " "), c);
+
+        // Add some blank space
+        mainPane.add(Box.createRigidArea(new Dimension(1, 5)), c);
+
+        // The listener info
+        // /////////////////////////////////////////////////////////////////
+        JPanel tmpPanel = new JPanel(new GridBagLayout());
+        c.anchor = GridBagConstraints.WEST;
+        c.gridwidth = 1;
+        tmpPanel.add(new JLabel(HTTPTracer.getMessage("listenPort00",
+                "Listen Port #")
+                + " "), c);
+        c.anchor = GridBagConstraints.WEST;
+        c.gridwidth = GridBagConstraints.REMAINDER;
+        tmpPanel.add(port = new NumberField(4), c);
+        mainPane.add(tmpPanel, c);
+        mainPane.add(Box.createRigidArea(new Dimension(1, 5)), c);
+
+        // Group for the radio buttons
+        ButtonGroup btns = new ButtonGroup();
+        c.anchor = GridBagConstraints.WEST;
+        c.gridwidth = GridBagConstraints.REMAINDER;
+        mainPane.add(new JLabel(HTTPTracer.getMessage("actAs00", "Act as a...")), c);
+
+        // Target Host/Port section
+        // /////////////////////////////////////////////////////////////////
+        c.anchor = GridBagConstraints.WEST;
+        c.gridwidth = GridBagConstraints.REMAINDER;
+        final String listener = HTTPTracer.getMessage("listener00", "Listener");
+        mainPane.add(listenerButton = new JRadioButton(listener), c);
+        btns.add(listenerButton);
+        listenerButton.setSelected(true);
+        listenerButton.addActionListener(new ActionListener() {
+            public void actionPerformed(ActionEvent event) {
+                if (listener.equals(event.getActionCommand())) {
+                    boolean state = listenerButton.isSelected();
+                    tport.setEnabled(state);
+                    host.setEnabled(state);
+                    hostLabel.setForeground(state
+                            ? Color.black
+                            : Color.gray);
+                    tportLabel.setForeground(state
+                            ? Color.black
+                            : Color.gray);
+                }
+            }
+        });
+        c.anchor = GridBagConstraints.WEST;
+        c.gridwidth = 1;
+        mainPane.add(Box.createRigidArea(new Dimension(25, 0)));
+        mainPane.add(hostLabel =
+                new JLabel(HTTPTracer.getMessage("targetHostname00",
+                        "Target Hostname")
+                + " "), c);
+        c.anchor = GridBagConstraints.WEST;
+        c.gridwidth = GridBagConstraints.REMAINDER;
+        host = new HostnameField(30);
+        mainPane.add(host, c);
+        host.setText(HTTPTracer.DEFAULT_HOST);
+        c.anchor = GridBagConstraints.WEST;
+        c.gridwidth = 1;
+        mainPane.add(Box.createRigidArea(new Dimension(25, 0)));
+        mainPane.add(tportLabel =
+                new JLabel(HTTPTracer.getMessage("targetPort00", "Target Port #")
+                + " "), c);
+        c.anchor = GridBagConstraints.WEST;
+        c.gridwidth = GridBagConstraints.REMAINDER;
+        tport = new NumberField(4);
+        mainPane.add(tport, c);
+        tport.setValue(HTTPTracer.DEFAULT_PORT);
+
+        // Act as proxy section
+        // /////////////////////////////////////////////////////////////////
+        c.anchor = GridBagConstraints.WEST;
+        c.gridwidth = GridBagConstraints.REMAINDER;
+        final String proxy = HTTPTracer.getMessage("proxy00", "Proxy");
+        mainPane.add(proxyButton = new JRadioButton(proxy), c);
+        btns.add(proxyButton);
+        proxyButton.addActionListener(new ActionListener() {
+            public void actionPerformed(ActionEvent event) {
+                if (proxy.equals(event.getActionCommand())) {
+                    boolean state = proxyButton.isSelected();
+                    tport.setEnabled(!state);
+                    host.setEnabled(!state);
+                    hostLabel.setForeground(state
+                            ? Color.gray
+                            : Color.black);
+                    tportLabel.setForeground(state
+                            ? Color.gray
+                            : Color.black);
+                }
+            }
+        });
+
+        // Spacer
+        // ///////////////////////////////////////////////////////////////
+        c.anchor = GridBagConstraints.WEST;
+        c.gridwidth = GridBagConstraints.REMAINDER;
+        mainPane.add(Box.createRigidArea(new Dimension(1, 10)), c);
+
+        // Options section
+        // /////////////////////////////////////////////////////////////////
+        JPanel opts = new JPanel(new GridBagLayout());
+        opts.setBorder(new TitledBorder(HTTPTracer.getMessage("options00",
+                "Options")));
+        c.anchor = GridBagConstraints.WEST;
+        c.gridwidth = GridBagConstraints.REMAINDER;
+        mainPane.add(opts, c);
+
+        // HTTP Proxy Support section
+        // /////////////////////////////////////////////////////////////////
+        c.anchor = GridBagConstraints.WEST;
+        c.gridwidth = GridBagConstraints.REMAINDER;
+        final String proxySupport = HTTPTracer.getMessage("proxySupport00",
+                "HTTP Proxy Support");
+        opts.add(HTTPProxyBox = new JCheckBox(proxySupport), c);
+        c.anchor = GridBagConstraints.WEST;
+        c.gridwidth = 1;
+        opts.add(HTTPProxyHostLabel =
+                new JLabel(HTTPTracer.getMessage("hostname00", "Hostname") + " "),
+                c);
+        HTTPProxyHostLabel.setForeground(Color.gray);
+        c.anchor = GridBagConstraints.WEST;
+        c.gridwidth = GridBagConstraints.REMAINDER;
+        opts.add(HTTPProxyHost = new HostnameField(30), c);
+        HTTPProxyHost.setEnabled(false);
+        c.anchor = GridBagConstraints.WEST;
+        c.gridwidth = 1;
+        opts.add(HTTPProxyPortLabel =
+                new JLabel(HTTPTracer.getMessage("port00", "Port #") + " "), c);
+        HTTPProxyPortLabel.setForeground(Color.gray);
+        c.anchor = GridBagConstraints.WEST;
+        c.gridwidth = GridBagConstraints.REMAINDER;
+        opts.add(HTTPProxyPort = new NumberField(4), c);
+        HTTPProxyPort.setEnabled(false);
+        HTTPProxyBox.addActionListener(new ActionListener() {
+            public void actionPerformed(ActionEvent event) {
+                if (proxySupport.equals(event.getActionCommand())) {
+                    boolean b = HTTPProxyBox.isSelected();
+                    Color color = b
+                            ? Color.black
+                            : Color.gray;
+                    HTTPProxyHost.setEnabled(b);
+                    HTTPProxyPort.setEnabled(b);
+                    HTTPProxyHostLabel.setForeground(color);
+                    HTTPProxyPortLabel.setForeground(color);
+                }
+            }
+        });
+
+        // Set default proxy values...
+        String tmp = System.getProperty("http.proxyHost");
+        if ((tmp != null) && tmp.equals("")) {
+            tmp = null;
+        }
+        HTTPProxyBox.setSelected(tmp != null);
+        HTTPProxyHost.setEnabled(tmp != null);
+        HTTPProxyPort.setEnabled(tmp != null);
+        HTTPProxyHostLabel.setForeground((tmp != null)
+                ? Color.black
+                : Color.gray);
+        HTTPProxyPortLabel.setForeground((tmp != null)
+                ? Color.black
+                : Color.gray);
+        if (tmp != null) {
+            HTTPProxyBox.setSelected(true);
+            HTTPProxyHost.setText(tmp);
+            tmp = System.getProperty("http.proxyPort");
+            if ((tmp != null) && tmp.equals("")) {
+                tmp = null;
+            }
+            if (tmp == null) {
+                tmp = "80";
+            }
+            HTTPProxyPort.setText(tmp);
+        }
+
+        // add byte delay fields
+        opts.add(Box.createRigidArea(new Dimension(1, 10)), c);
+        c.anchor = GridBagConstraints.WEST;
+        c.gridwidth = GridBagConstraints.REMAINDER;
+        final String delaySupport = HTTPTracer.getMessage("delay00",
+                "Simulate Slow Connection");
+        opts.add(delayBox = new JCheckBox(delaySupport), c);
+
+        // bytes per pause
+        c.anchor = GridBagConstraints.WEST;
+        c.gridwidth = 1;
+        delayBytesLabel = new JLabel(HTTPTracer.getMessage("delay01",
+                "Bytes per Pause"));
+        opts.add(delayBytesLabel, c);
+        delayBytesLabel.setForeground(Color.gray);
+        c.anchor = GridBagConstraints.WEST;
+        c.gridwidth = GridBagConstraints.REMAINDER;
+        opts.add(delayBytes = new NumberField(6), c);
+        delayBytes.setEnabled(false);
+
+        // delay interval
+        c.anchor = GridBagConstraints.WEST;
+        c.gridwidth = 1;
+        delayTimeLabel = new JLabel(HTTPTracer.getMessage("delay02",
+                "Delay in Milliseconds"));
+        opts.add(delayTimeLabel, c);
+        delayTimeLabel.setForeground(Color.gray);
+        c.anchor = GridBagConstraints.WEST;
+        c.gridwidth = GridBagConstraints.REMAINDER;
+        opts.add(delayTime = new NumberField(6), c);
+        delayTime.setEnabled(false);
+
+        // enabler callback
+        delayBox.addActionListener(new ActionListener() {
+            public void actionPerformed(ActionEvent event) {
+                if (delaySupport.equals(event.getActionCommand())) {
+                    boolean b = delayBox.isSelected();
+                    Color color = b
+                            ? Color.black
+                            : Color.gray;
+                    delayBytes.setEnabled(b);
+                    delayTime.setEnabled(b);
+                    delayBytesLabel.setForeground(color);
+                    delayTimeLabel.setForeground(color);
+                }
+            }
+        });
+
+        // Spacer
+        // ////////////////////////////////////////////////////////////////
+        mainPane.add(Box.createRigidArea(new Dimension(1, 10)), c);
+
+        // ADD Button
+        // /////////////////////////////////////////////////////////////////
+        c.anchor = GridBagConstraints.WEST;
+        c.gridwidth = GridBagConstraints.REMAINDER;
+        final String add = HTTPTracer.getMessage("add00", "Add");
+        mainPane.add(addButton = new JButton(add), c);
+        this.add(new JScrollPane(mainPane), BorderLayout.CENTER);
+
+        // addButton.setEnabled( false );
+        addButton.addActionListener(new ActionListener() {
+            public void actionPerformed(ActionEvent event) {
+                if (add.equals(event.getActionCommand())) {
+                    String text;
+                    Listener l = null;
+                    int lPort;
+                    lPort = port.getValue(0);
+                    if (lPort == 0) {
+
+                        // no port, button does nothing
+                        return;
+                    }
+                    String tHost = host.getText();
+                    int tPort = 0;
+                    tPort = tport.getValue(0);
+                    SlowLinkSimulator slowLink = null;
+                    if (delayBox.isSelected()) {
+                        int bytes = delayBytes.getValue(0);
+                        int time = delayTime.getValue(0);
+                        slowLink = new SlowLinkSimulator(bytes, time);
+                    }
+                    try {
+                        l = new Listener(noteb, null, lPort, tHost, tPort,
+                                proxyButton.isSelected(),
+                                slowLink);
+                    } catch (Exception e) {
+                        e.printStackTrace();
+                    }
+
+                    // Pick-up the HTTP Proxy settings
+                    // /////////////////////////////////////////////////
+                    text = HTTPProxyHost.getText();
+                    if ("".equals(text)) {
+                        text = null;
+                    }
+                    l.HTTPProxyHost = text;
+                    text = HTTPProxyPort.getText();
+                    int proxyPort = HTTPProxyPort.getValue(-1);
+                    if (proxyPort != -1) {
+                        l.HTTPProxyPort = Integer.parseInt(text);
+                    }
+
+                    // reset the port
+                    port.setText(null);
+                }
+            }
+        });
+        notebook.addTab(name, this);
+        notebook.repaint();
+        notebook.setSelectedIndex(notebook.getTabCount() - 1);
+    }
+    
+    /**
+     * a text field with a restricted set of characters
+     */
+    static class RestrictedTextField extends JTextField {
+        /**
+         * Field validText
+         */
+        protected String validText;
+
+        /**
+         * Constructor RestrictedTextField
+         *
+         * @param validText
+         */
+        public RestrictedTextField(String validText) {
+            setValidText(validText);
+        }
+
+        /**
+         * Constructor RestrictedTextField
+         *
+         * @param columns
+         * @param validText
+         */
+        public RestrictedTextField(int columns, String validText) {
+            super(columns);
+            setValidText(validText);
+        }
+
+        /**
+         * Constructor RestrictedTextField
+         *
+         * @param text
+         * @param validText
+         */
+        public RestrictedTextField(String text, String validText) {
+            super(text);
+            setValidText(validText);
+        }
+
+        /**
+         * Constructor RestrictedTextField
+         *
+         * @param text
+         * @param columns
+         * @param validText
+         */
+        public RestrictedTextField(String text, int columns, String validText) {
+            super(text, columns);
+            setValidText(validText);
+        }
+
+        /**
+         * Method setValidText
+         *
+         * @param validText
+         */
+        private void setValidText(String validText) {
+            this.validText = validText;
+        }
+
+        /**
+         * fascinatingly, this method is called in the super() constructor,
+         * meaning before we are fully initialized. C++ doesnt actually permit
+         * such a situation, but java clearly does...
+         *
+         * @return a new document
+         */
+        public Document createDefaultModel() {
+            return new RestrictedDocument();
+        }
+
+        /**
+         * this class strips out invaid chars
+         */
+        class RestrictedDocument extends PlainDocument {
+            /**
+             * Constructs a plain text document.  A default model using
+             * <code>GapContent</code> is constructed and set.
+             */
+            public RestrictedDocument() {
+            }
+
+            /**
+             * add a string; only those chars in the valid text list are allowed
+             *
+             * @param offset
+             * @param string
+             * @param attributes
+             * @throws BadLocationException
+             */
+            public void insertString(int offset,
+                                     String string,
+                                     AttributeSet attributes)
+                    throws BadLocationException {
+                if (string == null) {
+                    return;
+                }
+                int len = string.length();
+                StringBuffer buffer = new StringBuffer(string.length());
+                for (int i = 0; i < len; i++) {
+                    char ch = string.charAt(i);
+                    if (validText.indexOf(ch) >= 0) {
+                        buffer.append(ch);
+                    }
+                }
+                super.insertString(offset, new String(buffer), attributes);
+            }
+        }    // end class NumericDocument
+    }
+
+    /**
+     * because we cant use Java1.4's JFormattedTextField, here is
+     * a class that accepts numbers only
+     */
+    static class NumberField extends RestrictedTextField {
+        /**
+         * Field VALID_TEXT
+         */
+        private static final String VALID_TEXT = "0123456789";
+
+        /**
+         * Constructs a new <code>TextField</code>.  A default model is created,
+         * the initial string is <code>null</code>,
+         * and the number of columns is set to 0.
+         */
+        public NumberField() {
+            super(VALID_TEXT);
+        }
+
+        /**
+         * Constructs a new empty <code>TextField</code> with the specified
+         * number of columns.
+         * A default model is created and the initial string is set to
+         * <code>null</code>.
+         *
+         * @param columns the number of columns to use to calculate
+         *                the preferred width; if columns is set to zero, the
+         *                preferred width will be whatever naturally results from
+         *                the component implementation
+         */
+        public NumberField(int columns) {
+            super(columns, VALID_TEXT);
+        }
+
+        /**
+         * get the int value of a field, any invalid (non int) field returns
+         * the default
+         *
+         * @param def default value
+         * @return the field contents
+         */
+        public int getValue(int def) {
+            int result = def;
+            String text = getText();
+            if ((text != null) && (text.length() != 0)) {
+                try {
+                    result = Integer.parseInt(text);
+                } catch (NumberFormatException e) {
+                }
+            }
+            return result;
+        }
+
+        /**
+         * set the text to a numeric value
+         *
+         * @param value number to assign
+         */
+        public void setValue(int value) {
+            setText(Integer.toString(value));
+        }
+    }    // end class NumericTextField
+
+    /**
+     * hostname fields
+     */
+    static class HostnameField extends RestrictedTextField {
+
+        // list of valid chars in a hostname
+
+        /**
+         * Field VALID_TEXT
+         */
+        private static final String VALID_TEXT =
+                "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWZYZ-.";
+
+        /**
+         * Constructor HostnameField
+         *
+         * @param columns
+         */
+        public HostnameField(int columns) {
+            super(columns, VALID_TEXT);
+        }
+
+        /**
+         * Constructor HostnameField
+         */
+        public HostnameField() {
+            super(VALID_TEXT);
+        }
+    }    
+}
+

Added: webservices/axis2/trunk/java/modules/tool/src/org/apache/axis2/tool/tracer/Connection.java
URL: http://svn.apache.org/viewcvs/webservices/axis2/trunk/java/modules/tool/src/org/apache/axis2/tool/tracer/Connection.java?rev=289655&view=auto
==============================================================================
--- webservices/axis2/trunk/java/modules/tool/src/org/apache/axis2/tool/tracer/Connection.java (added)
+++ webservices/axis2/trunk/java/modules/tool/src/org/apache/axis2/tool/tracer/Connection.java Fri Sep 16 14:30:29 2005
@@ -0,0 +1,505 @@
+/*
+ * Copyright 2004,2005 The Apache Software Foundation.
+ *
+ * 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.apache.axis2.tool.tracer;
+
+import javax.swing.JScrollPane;
+import javax.swing.JTextArea;
+import javax.swing.ListSelectionModel;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.io.PrintWriter;
+import java.io.StringWriter;
+import java.net.Socket;
+import java.net.URL;
+import java.text.DateFormat;
+import java.text.SimpleDateFormat;
+import java.util.Date;
+
+/**
+ * a connection listens to a single current connection
+ */
+class Connection extends Thread {
+
+	/**
+     * Field listener
+     */
+    Listener listener;
+
+    /**
+     * Field active
+     */
+    boolean active;
+
+    /**
+     * Field fromHost
+     */
+    String fromHost;
+
+    /**
+     * Field time
+     */
+    String time;
+
+    /**
+     * Field elapsed time
+     */
+    long elapsedTime;
+    
+    /**
+     * Field inputText
+     */
+    JTextArea inputText = null;
+
+    /**
+     * Field inputScroll
+     */
+    JScrollPane inputScroll = null;
+
+    /**
+     * Field outputText
+     */
+    JTextArea outputText = null;
+
+    /**
+     * Field outputScroll
+     */
+    JScrollPane outputScroll = null;
+
+    /**
+     * Field inSocket
+     */
+    Socket inSocket = null;
+
+    /**
+     * Field outSocket
+     */
+    Socket outSocket = null;
+
+    /**
+     * Field clientThread
+     */
+    Thread clientThread = null;
+
+    /**
+     * Field serverThread
+     */
+    Thread serverThread = null;
+
+    /**
+     * Field rr1
+     */
+    SocketRR rr1 = null;
+
+    /**
+     * Field rr2
+     */
+    SocketRR rr2 = null;
+
+    /**
+     * Field inputStream
+     */
+    InputStream inputStream = null;
+
+    /**
+     * Field HTTPProxyHost
+     */
+    String HTTPProxyHost = null;
+
+    /**
+     * Field HTTPProxyPort
+     */
+    int HTTPProxyPort = 80;
+
+    /**
+     * Field slowLink
+     */
+    private SlowLinkSimulator slowLink;
+
+    /**
+     * Constructor Connection
+     *
+     * @param l
+     */
+    public Connection(Listener l) {
+        listener = l;
+        HTTPProxyHost = l.HTTPProxyHost;
+        HTTPProxyPort = l.HTTPProxyPort;
+        slowLink = l.slowLink;
+    }
+
+    /**
+     * Constructor Connection
+     *
+     * @param l
+     * @param s
+     */
+    public Connection(Listener l, Socket s) {
+        this(l);
+        inSocket = s;
+        start();
+    }
+
+    /**
+     * Constructor Connection
+     *
+     * @param l
+     * @param in
+     */
+    public Connection(Listener l, InputStream in) {
+        this(l);
+        inputStream = in;
+        start();
+    }
+
+    /**
+     * Method run
+     */
+    public void run() {
+        try {
+            active = true;
+            HTTPProxyHost = System.getProperty("http.proxyHost");
+            if ((HTTPProxyHost != null) && HTTPProxyHost.equals("")) {
+                HTTPProxyHost = null;
+            }
+            if (HTTPProxyHost != null) {
+                String tmp = System.getProperty("http.proxyPort");
+                if ((tmp != null) && tmp.equals("")) {
+                    tmp = null;
+                }
+                if (tmp == null) {
+                    HTTPProxyPort = 80;
+                } else {
+                    HTTPProxyPort = Integer.parseInt(tmp);
+                }
+            }
+            if (inSocket != null) {
+                fromHost = (inSocket.getInetAddress()).getHostName();
+            } else {
+                fromHost = "resend";
+            }
+            String dateformat = HTTPTracer.getMessage("dateformat00", "yyyy-MM-dd HH:mm:ss");
+            DateFormat df = new SimpleDateFormat(dateformat);
+            time = df.format(new Date());
+            int count = listener.connections.size();
+            listener.tableModel.insertRow(count + 1,
+                    new Object[]{
+                        HTTPTracer.getMessage("active00","Active"),
+                        time,
+                        fromHost,
+                        listener.hostField.getText(),
+                        ""});
+            listener.connections.add(this);
+            inputText = new JTextArea(null, null, 20, 80);
+            inputScroll = new JScrollPane(inputText);
+            outputText = new JTextArea(null, null, 20, 80);
+            outputScroll = new JScrollPane(outputText);
+            ListSelectionModel lsm = listener.connectionTable.getSelectionModel();
+            if ((count == 0) || (lsm.getLeadSelectionIndex() == 0)) {
+                listener.outPane.setVisible(false);
+                int divLoc = listener.outPane.getDividerLocation();
+                listener.setLeft(inputScroll);
+                listener.setRight(outputScroll);
+                listener.removeButton.setEnabled(false);
+                listener.removeAllButton.setEnabled(true);
+                listener.saveButton.setEnabled(true);
+                listener.resendButton.setEnabled(true);
+                listener.outPane.setDividerLocation(divLoc);
+                listener.outPane.setVisible(true);
+            }
+            String targetHost = listener.hostField.getText();
+            int targetPort = Integer.parseInt(listener.tPortField.getText());
+            int listenPort = Integer.parseInt(listener.portField.getText());
+            InputStream tmpIn1 = inputStream;
+            OutputStream tmpOut1 = null;
+            InputStream tmpIn2 = null;
+            OutputStream tmpOut2 = null;
+            if (tmpIn1 == null) {
+                tmpIn1 = inSocket.getInputStream();
+            }
+            if (inSocket != null) {
+                tmpOut1 = inSocket.getOutputStream();
+            }
+            String bufferedData = null;
+            StringBuffer buf = null;
+            int index = listener.connections.indexOf(this);
+            if (listener.isProxyBox.isSelected() || (HTTPProxyHost != null)) {
+
+                // Check if we're a proxy
+                byte[] b = new byte[1];
+                buf = new StringBuffer();
+                String s;
+                for (; ;) {
+                    int len;
+                    len = tmpIn1.read(b, 0, 1);
+                    if (len == -1) {
+                        break;
+                    }
+                    s = new String(b);
+                    buf.append(s);
+                    if (b[0] != '\n') {
+                        continue;
+                    }
+                    break;
+                }
+                bufferedData = buf.toString();
+                inputText.append(bufferedData);
+                if (bufferedData.startsWith("GET ")
+                        || bufferedData.startsWith("POST ")
+                        || bufferedData.startsWith("PUT ")
+                        || bufferedData.startsWith("DELETE ")) {
+                    int start, end;
+                    URL url;
+                    start = bufferedData.indexOf(' ') + 1;
+                    while (bufferedData.charAt(start) == ' ') {
+                        start++;
+                    }
+                    end = bufferedData.indexOf(' ', start);
+                    String urlString = bufferedData.substring(start, end);
+                    if (urlString.charAt(0) == '/') {
+                        urlString = urlString.substring(1);
+                    }
+                    if (listener.isProxyBox.isSelected()) {
+                        url = new URL(urlString);
+                        targetHost = url.getHost();
+                        targetPort = url.getPort();
+                        if (targetPort == -1) {
+                            targetPort = 80;
+                        }
+                        listener.tableModel.setValueAt(targetHost,
+                                index + 1,
+                                HTTPTracer.OUTHOST_COLUMN);
+                        bufferedData = bufferedData.substring(0, start)
+                                + url.getFile()
+                                + bufferedData.substring(end);
+                    } else {
+                        url = new URL("http://" + targetHost + ":"
+                                + targetPort + "/" + urlString);
+                        listener.tableModel.setValueAt(targetHost,
+                                index + 1,
+                                HTTPTracer.OUTHOST_COLUMN);
+                        bufferedData = bufferedData.substring(0, start)
+                                + url.toExternalForm()
+                                + bufferedData.substring(end);
+                        targetHost = HTTPProxyHost;
+                        targetPort = HTTPProxyPort;
+                    }
+                }
+            } else {
+
+                // 
+                // Change Host: header to point to correct host
+                // 
+                byte[] b1 = new byte[1];
+                buf = new StringBuffer();
+                String s1;
+                String lastLine = null;
+                for (; ;) {
+                    int len;
+                    len = tmpIn1.read(b1, 0, 1);
+                    if (len == -1) {
+                        break;
+                    }
+                    s1 = new String(b1);
+                    buf.append(s1);
+                    if (b1[0] != '\n') {
+                        continue;
+                    }
+
+                    // we have a complete line
+                    String line = buf.toString();
+                    buf.setLength(0);
+
+                    // check to see if we have found Host: header
+                    if (line.startsWith("Host: ")) {
+
+                        // we need to update the hostname to target host
+                        String newHost = "Host: " + targetHost + ":"
+                                + listenPort + "\r\n";
+                        bufferedData = bufferedData.concat(newHost);
+                        break;
+                    }
+
+                    // add it to our headers so far
+                    if (bufferedData == null) {
+                        bufferedData = line;
+                    } else {
+                        bufferedData = bufferedData.concat(line);
+                    }
+
+                    // failsafe
+                    if (line.equals("\r\n")) {
+                        break;
+                    }
+                    if ("\n".equals(lastLine) && line.equals("\n")) {
+                        break;
+                    }
+                    lastLine = line;
+                }
+                if (bufferedData != null) {
+                    inputText.append(bufferedData);
+                    int idx = (bufferedData.length() < 50)
+                            ? bufferedData.length()
+                            : 50;
+                    s1 = bufferedData.substring(0, idx);
+                    int i = s1.indexOf('\n');
+                    if (i > 0) {
+                        s1 = s1.substring(0, i - 1);
+                    }
+                    s1 = s1 + "                           "
+                            + "                       ";
+                    s1 = s1.substring(0, 51);
+                    listener.tableModel.setValueAt(s1, index + 1,
+                    		HTTPTracer.REQ_COLUMN);
+                }
+            }
+            if (targetPort == -1) {
+                targetPort = 80;
+            }
+            outSocket = new Socket(targetHost, targetPort);
+            tmpIn2 = outSocket.getInputStream();
+            tmpOut2 = outSocket.getOutputStream();
+            if (bufferedData != null) {
+                byte[] b = bufferedData.getBytes();
+                tmpOut2.write(b);
+                slowLink.pump(b.length);
+            }
+            boolean format = listener.xmlFormatBox.isSelected();
+
+            // this is the channel to the endpoint
+            rr1 = new SocketRR(this, inSocket, tmpIn1, outSocket, tmpOut2,
+                    inputText, format, listener.tableModel,
+                    index + 1, "request:", slowLink);
+
+            // create the response slow link from the inbound slow link
+            SlowLinkSimulator responseLink =
+                    new SlowLinkSimulator(slowLink);
+
+            // this is the channel from the endpoint
+            rr2 = new SocketRR(this, outSocket, tmpIn2, inSocket, tmpOut1,
+                    outputText, format, null, 0, "response:",
+                    responseLink);
+            
+            while ((rr1 != null) || (rr2 != null)) {
+
+            		if (rr2 != null) {
+            			listener.tableModel.setValueAt(rr2.getElapsed(), 1 + index, HTTPTracer.ELAPSED_COLUMN);
+            		}
+            		
+                // Only loop as long as the connection to the target
+                // machine is available - once that's gone we can stop.
+                // The old way, loop until both are closed, left us
+                // looping forever since no one closed the 1st one.
+            	
+                if ((null != rr1) && rr1.isDone()) {
+                    if ((index >= 0) && (rr2 != null)) {
+                        listener.tableModel.setValueAt(
+                                HTTPTracer.getMessage("resp00", "Resp"), 1 + index,
+                                HTTPTracer.STATE_COLUMN);
+                    }
+                    rr1 = null;
+                }
+
+                if ((null != rr2) && rr2.isDone()) {
+                    if ((index >= 0) && (rr1 != null)) {
+                        listener.tableModel.setValueAt(
+                                HTTPTracer.getMessage("req00", "Req"), 1 + index,
+                                HTTPTracer.STATE_COLUMN);
+                    }
+                    rr2 = null;
+                }
+
+                synchronized (this) {
+                    this.wait(100);    // Safety just incase we're not told to wake up.
+                }
+            }
+
+            active = false;
+
+            if (index >= 0) {
+                listener.tableModel.setValueAt(
+                        HTTPTracer.getMessage("done00", "Done"),
+                        1 + index, HTTPTracer.STATE_COLUMN);
+            }
+
+        } catch (Exception e) {
+            StringWriter st = new StringWriter();
+            PrintWriter wr = new PrintWriter(st);
+            int index = listener.connections.indexOf(this);
+            if (index >= 0) {
+                listener.tableModel.setValueAt(
+                        HTTPTracer.getMessage("error00", "Error"), 1 + index,
+                        HTTPTracer.STATE_COLUMN);
+            }
+            e.printStackTrace(wr);
+            wr.close();
+            if (outputText != null) {
+                outputText.append(st.toString());
+            } else {
+                // something went wrong before we had the output area
+                System.out.println(st.toString());
+            }
+            halt();
+        }
+    }
+
+    /**
+     * Method wakeUp
+     */
+    synchronized void wakeUp() {
+        this.notifyAll();
+    }
+
+    /**
+     * Method halt
+     */
+    public void halt() {
+        try {
+            if (rr1 != null) {
+                rr1.halt();
+            }
+            if (rr2 != null) {
+                rr2.halt();
+            }
+            if (inSocket != null) {
+                inSocket.close();
+            }
+            inSocket = null;
+            if (outSocket != null) {
+                outSocket.close();
+            }
+            outSocket = null;
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+
+    /**
+     * Method remove
+     */
+    public void remove() {
+        int index = -1;
+        try {
+            halt();
+            index = listener.connections.indexOf(this);
+            listener.tableModel.removeRow(index + 1);
+            listener.connections.remove(index);
+        } catch (Exception e) {
+            System.err.println("index:=" + index + this);
+            e.printStackTrace();
+        }
+    }
+}

Added: webservices/axis2/trunk/java/modules/tool/src/org/apache/axis2/tool/tracer/HTTPTracer.java
URL: http://svn.apache.org/viewcvs/webservices/axis2/trunk/java/modules/tool/src/org/apache/axis2/tool/tracer/HTTPTracer.java?rev=289655&view=auto
==============================================================================
--- webservices/axis2/trunk/java/modules/tool/src/org/apache/axis2/tool/tracer/HTTPTracer.java (added)
+++ webservices/axis2/trunk/java/modules/tool/src/org/apache/axis2/tool/tracer/HTTPTracer.java Fri Sep 16 14:30:29 2005
@@ -0,0 +1,218 @@
+/*
+ * Copyright 2004,2005 The Apache Software Foundation.
+ *
+ * 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.apache.axis2.tool.tracer;
+
+import javax.swing.JFrame;
+import javax.swing.JTabbedPane;
+import javax.swing.UIManager;
+import javax.swing.UnsupportedLookAndFeelException;
+import java.util.ResourceBundle;
+
+/**
+ * Proxy that sniffs and shows HTTP messages and responses, both SOAP and plain HTTP.
+ *
+ * @author Doug Davis
+ * @author Steve Loughran
+ * @author Stefano Mazzocchi
+ */
+
+public class HTTPTracer extends JFrame {
+
+    /**
+     * Field notebook
+     */
+    private JTabbedPane notebook = null;
+
+    /**
+     * Field STATE_COLUMN
+     */
+    static final int STATE_COLUMN = 0;
+
+    /**
+     * Field OUTHOST_COLUMN
+     */
+    static final int OUTHOST_COLUMN = 3;
+
+    /**
+     * Field REQ_COLUMN
+     */
+    static final int REQ_COLUMN = 4;
+
+    /**
+     * Field ELAPSED_COLUMN
+     */
+    static final int ELAPSED_COLUMN = 5;
+    
+    /**
+     * Field DEFAULT_HOST
+     */
+    static final String DEFAULT_HOST = "127.0.0.1";
+
+    /**
+     * Field DEFAULT_PORT
+     */
+    static final int DEFAULT_PORT = 8888;
+
+    /**
+     * Constructor
+     *
+     * @param listenPort
+     * @param targetHost
+     * @param targetPort
+     * @param embedded
+     */
+    public HTTPTracer(int listenPort, String targetHost, int targetPort, boolean embedded) {
+        super(getMessage("httptracer00","HTTPTracer"));
+        notebook = new JTabbedPane();
+        this.getContentPane().add(notebook);
+        new AdminPane(notebook, getMessage("admin00", "Admin"));
+        if (listenPort != 0) {
+            Listener l = null;
+            if (targetHost == null) {
+                l = new Listener(notebook, null, listenPort, targetHost, targetPort, true, null);
+            } else {
+                l = new Listener(notebook, null, listenPort, targetHost, targetPort, false, null);
+            }
+            notebook.setSelectedIndex(1);
+            l.HTTPProxyHost = System.getProperty("http.proxyHost");
+            if ((l.HTTPProxyHost != null) && l.HTTPProxyHost.equals("")) {
+                l.HTTPProxyHost = null;
+            }
+            if (l.HTTPProxyHost != null) {
+                String tmp = System.getProperty("http.proxyPort");
+                if ((tmp != null) && tmp.equals("")) {
+                    tmp = null;
+                }
+                if (tmp == null) {
+                    l.HTTPProxyPort = 80;
+                } else {
+                    l.HTTPProxyPort = Integer.parseInt(tmp);
+                }
+            }
+        }
+        if (!embedded) {
+            this.setDefaultCloseOperation(EXIT_ON_CLOSE);
+        }
+        this.pack();
+        this.setSize(1000, 700);
+        this.setVisible(true);
+    }
+
+    /**
+     * Constructor
+     *
+     * @param listenPort
+     * @param targetHost
+     * @param targetPort
+     */
+    public HTTPTracer(int listenPort, String targetHost, int targetPort) {
+        this(listenPort, targetHost, targetPort, false);
+    }
+
+    /**
+     * set up the L&F
+     *
+     * @param nativeLookAndFeel
+     * @throws Exception
+     */
+    private static void setupLookAndFeel(boolean nativeLookAndFeel) throws Exception {
+        String classname = UIManager.getCrossPlatformLookAndFeelClassName();
+        if (nativeLookAndFeel) {
+            classname = UIManager.getSystemLookAndFeelClassName();
+        }
+        String lafProperty = System.getProperty("httptracer.laf", "");
+        if (lafProperty.length() > 0) {
+            classname = lafProperty;
+        }
+        try {
+            UIManager.setLookAndFeel(classname);
+        } catch (ClassNotFoundException e) {
+            e.printStackTrace();
+        } catch (InstantiationException e) {
+            e.printStackTrace();
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+        } catch (UnsupportedLookAndFeelException e) {
+            e.printStackTrace();
+        }
+    }
+
+    /**
+     * this is our main method
+     *
+     * @param args
+     */
+    public static void main(String[] args) {
+        try {
+
+            // switch between swing L&F here
+            setupLookAndFeel(true);
+            if (args.length == 3) {
+                int p1 = Integer.parseInt(args[0]);
+                int p2 = Integer.parseInt(args[2]);
+                new HTTPTracer(p1, args[1], p2);
+            } else if (args.length == 1) {
+                int p1 = Integer.parseInt(args[0]);
+                new HTTPTracer(p1, null, 0);
+            } else if (args.length != 0) {
+                System.err.println(
+                        getMessage("usage00", "Usage:")
+                        + " HTTPTracer [listenPort targetHost targetPort]\n");
+            } else {
+                new HTTPTracer(0, null, 0);
+            }
+        } catch (Throwable exp) {
+            exp.printStackTrace();
+        }
+    }
+
+    /**
+     * Field messages
+     */
+    private static ResourceBundle messages = null;
+
+    /**
+     * Get the message with the given key.  There are no arguments for this message.
+     *
+     * @param key
+     * @param defaultMsg
+     * @return string
+     */
+    public static String getMessage(String key, String defaultMsg) {
+        try {
+            if (messages == null) {
+                initializeMessages();
+            }
+            return messages.getString(key);
+        } catch (Throwable t) {
+
+            // If there is any problem whatsoever getting the internationalized
+            // message, return the default.
+            return defaultMsg;
+        }
+    }
+
+    /**
+     * Load the resource bundle messages from the properties file.  This is ONLY done when it is
+     * needed.  If no messages are printed (for example, only Wsdl2java is being run in non-
+     * verbose mode) then there is no need to read the properties file.
+     */
+    private static void initializeMessages() {
+        messages = ResourceBundle.getBundle("org.apache.axis2.tool.tracer.httptracer");
+    }
+
+}

Added: webservices/axis2/trunk/java/modules/tool/src/org/apache/axis2/tool/tracer/Listener.java
URL: http://svn.apache.org/viewcvs/webservices/axis2/trunk/java/modules/tool/src/org/apache/axis2/tool/tracer/Listener.java?rev=289655&view=auto
==============================================================================
--- webservices/axis2/trunk/java/modules/tool/src/org/apache/axis2/tool/tracer/Listener.java (added)
+++ webservices/axis2/trunk/java/modules/tool/src/org/apache/axis2/tool/tracer/Listener.java Fri Sep 16 14:30:29 2005
@@ -0,0 +1,692 @@
+/*
+ * Copyright 2004,2005 The Apache Software Foundation.
+ *
+ * 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.apache.axis2.tool.tracer;
+
+import javax.swing.BorderFactory;
+import javax.swing.Box;
+import javax.swing.BoxLayout;
+import javax.swing.JButton;
+import javax.swing.JCheckBox;
+import javax.swing.JFileChooser;
+import javax.swing.JLabel;
+import javax.swing.JPanel;
+import javax.swing.JScrollPane;
+import javax.swing.JSplitPane;
+import javax.swing.JTabbedPane;
+import javax.swing.JTable;
+import javax.swing.JTextField;
+import javax.swing.ListSelectionModel;
+import javax.swing.SwingConstants;
+import javax.swing.event.ChangeEvent;
+import javax.swing.event.ListSelectionEvent;
+import javax.swing.event.ListSelectionListener;
+import javax.swing.plaf.basic.BasicButtonListener;
+import javax.swing.table.DefaultTableModel;
+import javax.swing.table.TableColumn;
+import java.awt.BorderLayout;
+import java.awt.Component;
+import java.awt.Dimension;
+import java.awt.event.ActionEvent;
+import java.awt.event.ActionListener;
+import java.io.ByteArrayInputStream;
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.InputStream;
+import java.net.ServerSocket;
+import java.net.Socket;
+import java.util.Iterator;
+import java.util.Vector;
+
+/**
+ * this is one of the tabbed panels that acts as the actual proxy
+ */
+class Listener extends JPanel {
+
+	/**
+     * Field inputSocket
+     */
+    public Socket inputSocket = null;
+
+    /**
+     * Field outputSocket
+     */
+    public Socket outputSocket = null;
+
+    /**
+     * Field portField
+     */
+    public JTextField portField = null;
+
+    /**
+     * Field hostField
+     */
+    public JTextField hostField = null;
+
+    /**
+     * Field tPortField
+     */
+    public JTextField tPortField = null;
+
+    /**
+     * Field isProxyBox
+     */
+    public JCheckBox isProxyBox = null;
+
+    /**
+     * Field stopButton
+     */
+    public JButton stopButton = null;
+
+    /**
+     * Field removeButton
+     */
+    public JButton removeButton = null;
+
+    /**
+     * Field removeAllButton
+     */
+    public JButton removeAllButton = null;
+
+    /**
+     * Field xmlFormatBox
+     */
+    public JCheckBox xmlFormatBox = null;
+
+    /**
+     * Field saveButton
+     */
+    public JButton saveButton = null;
+
+    /**
+     * Field resendButton
+     */
+    public JButton resendButton = null;
+
+    /**
+     * Field switchButton
+     */
+    public JButton switchButton = null;
+
+    /**
+     * Field closeButton
+     */
+    public JButton closeButton = null;
+
+    /**
+     * Field connectionTable
+     */
+    public JTable connectionTable = null;
+
+    /**
+     * Field tableModel
+     */
+    public DefaultTableModel tableModel = null;
+
+    /**
+     * Field outPane
+     */
+    public JSplitPane outPane = null;
+
+    /**
+     * Field sSocket
+     */
+    public ServerSocket sSocket = null;
+
+    /**
+     * Field sw
+     */
+    public SocketWaiter sw = null;
+
+    /**
+     * Field leftPanel
+     */
+    public JPanel leftPanel = null;
+
+    /**
+     * Field rightPanel
+     */
+    public JPanel rightPanel = null;
+
+    /**
+     * Field notebook
+     */
+    public JTabbedPane notebook = null;
+
+    /**
+     * Field HTTPProxyHost
+     */
+    public String HTTPProxyHost = null;
+
+    /**
+     * Field HTTPProxyPort
+     */
+    public int HTTPProxyPort = 80;
+
+    /**
+     * Field delayBytes
+     */
+    public int delayBytes = 0;
+
+    /**
+     * Field delayTime
+     */
+    public int delayTime = 0;
+
+    /**
+     * Field slowLink
+     */
+    public SlowLinkSimulator slowLink;
+
+    /**
+     * Field connections
+     */
+    public final Vector connections = new Vector();
+
+    /**
+     * create a listener
+     *
+     * @param _notebook
+     * @param name
+     * @param listenPort
+     * @param host
+     * @param targetPort
+     * @param isProxy
+     * @param slowLink   optional reference to a slow connection
+     */
+    public Listener(JTabbedPane _notebook, String name, int listenPort,
+                    String host, int targetPort, boolean isProxy,
+                    SlowLinkSimulator slowLink) {
+        notebook = _notebook;
+        if (name == null) {
+            name = HTTPTracer.getMessage("port01", "Port") + " " + listenPort;
+        }
+
+        // set the slow link to the passed down link
+        if (slowLink != null) {
+            this.slowLink = slowLink;
+        } else {
+
+            // or make up a no-op one.
+            this.slowLink = new SlowLinkSimulator(0, 0);
+        }
+        this.setLayout(new BorderLayout());
+
+        // 1st component is just a row of labels and 1-line entry fields
+        // ///////////////////////////////////////////////////////////////////
+        JPanel top = new JPanel();
+        top.setLayout(new BoxLayout(top, BoxLayout.X_AXIS));
+        top.setBorder(BorderFactory.createEmptyBorder(5, 5, 5, 5));
+        final String start = HTTPTracer.getMessage("start00", "Start");
+        top.add(stopButton = new JButton(start));
+        top.add(Box.createRigidArea(new Dimension(5, 0)));
+        top.add(new JLabel("  "
+                + HTTPTracer.getMessage("listenPort01", "Listen Port:")
+                + " ", SwingConstants.RIGHT));
+        top.add(portField = new JTextField("" + listenPort, 4));
+        top.add(new JLabel("  " + HTTPTracer.getMessage("host00", "Host:"),
+                SwingConstants.RIGHT));
+        top.add(hostField = new JTextField(host, 30));
+        top.add(new JLabel("  " + HTTPTracer.getMessage("port02", "Port:") + " ",
+                SwingConstants.RIGHT));
+        top.add(tPortField = new JTextField("" + targetPort, 4));
+        top.add(Box.createRigidArea(new Dimension(5, 0)));
+        top.add(isProxyBox = new JCheckBox(HTTPTracer.getMessage("proxy00", "Proxy")));
+        isProxyBox.addChangeListener(new BasicButtonListener(isProxyBox) {
+            public void stateChanged(ChangeEvent event) {
+                JCheckBox box = (JCheckBox) event.getSource();
+                boolean state = box.isSelected();
+                tPortField.setEnabled(!state);
+                hostField.setEnabled(!state);
+            }
+        });
+        isProxyBox.setSelected(isProxy);
+        portField.setEditable(false);
+        portField.setMaximumSize(new Dimension(50, Short.MAX_VALUE));
+        hostField.setEditable(false);
+        hostField.setMaximumSize(new Dimension(85, Short.MAX_VALUE));
+        tPortField.setEditable(false);
+        tPortField.setMaximumSize(new Dimension(50, Short.MAX_VALUE));
+        stopButton.addActionListener(new ActionListener() {
+            public void actionPerformed(ActionEvent event) {
+                if (HTTPTracer.getMessage("stop00",
+                        "Stop").equals(event.getActionCommand())) {
+                    stop();
+                }
+                if (start.equals(event.getActionCommand())) {
+                    start();
+                }
+            }
+        });
+        this.add(top, BorderLayout.NORTH);
+
+        // 2nd component is a split pane with a table on the top
+        // and the request/response text areas on the bottom
+        // ///////////////////////////////////////////////////////////////////
+        tableModel = new DefaultTableModel(new String[]{
+            HTTPTracer.getMessage("state00", "State"),
+            HTTPTracer.getMessage("time00", "Time"),
+            HTTPTracer.getMessage("requestHost00", "Request Host"),
+            HTTPTracer.getMessage("targetHost", "Target Host"),
+            HTTPTracer.getMessage("request00", "Request..."),
+            HTTPTracer.getMessage("elapsed00", "Elapsed Time")}, 0);
+        tableModel.addRow(new Object[]{"---",
+                                       HTTPTracer.getMessage("mostRecent00",
+                                               "Most Recent"),
+                                       "---", "---", "---", "---"});
+        connectionTable = new JTable(1, 2);
+        connectionTable.setModel(tableModel);
+        connectionTable.setSelectionMode(
+                ListSelectionModel.MULTIPLE_INTERVAL_SELECTION);
+
+        // Reduce the STATE column and increase the REQ column
+        TableColumn col;
+        col = connectionTable.getColumnModel().getColumn(HTTPTracer.STATE_COLUMN);
+        col.setMaxWidth(col.getPreferredWidth() / 2);
+        col = connectionTable.getColumnModel().getColumn(HTTPTracer.REQ_COLUMN);
+        col.setPreferredWidth(col.getPreferredWidth() * 2);
+        ListSelectionModel sel = connectionTable.getSelectionModel();
+        sel.addListSelectionListener(new ListSelectionListener() {
+            public void valueChanged(ListSelectionEvent event) {
+                if (event.getValueIsAdjusting()) {
+                    return;
+                }
+                ListSelectionModel m =
+                        (ListSelectionModel) event.getSource();
+                int divLoc = outPane.getDividerLocation();
+                if (m.isSelectionEmpty()) {
+                    setLeft(
+                            new JLabel(
+                                    " "
+                            +
+                            HTTPTracer.getMessage("wait00",
+                                    "Waiting for Connection...")));
+                    setRight(new JLabel(""));
+                    removeButton.setEnabled(false);
+                    removeAllButton.setEnabled(false);
+                    saveButton.setEnabled(false);
+                    resendButton.setEnabled(false);
+                } else {
+                    int row = m.getLeadSelectionIndex();
+                    if (row == 0) {
+                        if (connections.size() == 0) {
+                            setLeft(
+                                    new JLabel(
+                                            " "
+                                    +
+                                    HTTPTracer.getMessage("wait00",
+                                            "Waiting for connection...")));
+                            setRight(new JLabel(""));
+                            removeButton.setEnabled(false);
+                            removeAllButton.setEnabled(false);
+                            saveButton.setEnabled(false);
+                            resendButton.setEnabled(false);
+                        } else {
+                            Connection conn =
+                                    (Connection) connections.lastElement();
+                            setLeft(conn.inputScroll);
+                            setRight(conn.outputScroll);
+                            removeButton.setEnabled(false);
+                            removeAllButton.setEnabled(true);
+                            saveButton.setEnabled(true);
+                            resendButton.setEnabled(true);
+                        }
+                    } else {
+                        Connection conn = (Connection) connections.get(row
+                                - 1);
+                        setLeft(conn.inputScroll);
+                        setRight(conn.outputScroll);
+                        removeButton.setEnabled(true);
+                        removeAllButton.setEnabled(true);
+                        saveButton.setEnabled(true);
+                        resendButton.setEnabled(true);
+                    }
+                }
+                outPane.setDividerLocation(divLoc);
+            }
+        });
+        JPanel tablePane = new JPanel();
+        tablePane.setLayout(new BorderLayout());
+        JScrollPane tableScrollPane = new JScrollPane(connectionTable);
+        tablePane.add(tableScrollPane, BorderLayout.CENTER);
+        JPanel buttons = new JPanel();
+        buttons.setLayout(new BoxLayout(buttons, BoxLayout.X_AXIS));
+        buttons.setBorder(BorderFactory.createEmptyBorder(5, 5, 5, 5));
+        final String removeSelected = HTTPTracer.getMessage("removeSelected00",
+                "Remove Selected");
+        buttons.add(removeButton = new JButton(removeSelected));
+        buttons.add(Box.createRigidArea(new Dimension(5, 0)));
+        final String removeAll = HTTPTracer.getMessage("removeAll00", "Remove All");
+        buttons.add(removeAllButton = new JButton(removeAll));
+        tablePane.add(buttons, BorderLayout.SOUTH);
+        removeButton.setEnabled(false);
+        removeButton.addActionListener(new ActionListener() {
+            public void actionPerformed(ActionEvent event) {
+                if (removeSelected.equals(event.getActionCommand())) {
+                    remove();
+                }
+            }
+        });
+        removeAllButton.setEnabled(false);
+        removeAllButton.addActionListener(new ActionListener() {
+            public void actionPerformed(ActionEvent event) {
+                if (removeAll.equals(event.getActionCommand())) {
+                    removeAll();
+                }
+            }
+        });
+
+        // Add Response Section
+        // ///////////////////////////////////////////////////////////////////
+        JPanel pane2 = new JPanel();
+        pane2.setLayout(new BorderLayout());
+        leftPanel = new JPanel();
+        leftPanel.setAlignmentX(Component.LEFT_ALIGNMENT);
+        leftPanel.setLayout(new BoxLayout(leftPanel, BoxLayout.Y_AXIS));
+        leftPanel.add(new JLabel("  "
+                + HTTPTracer.getMessage("request01", "Request")));
+        leftPanel.add(new JLabel(" "
+                + HTTPTracer.getMessage("wait01",
+                        "Waiting for connection")));
+        rightPanel = new JPanel();
+        rightPanel.setLayout(new BoxLayout(rightPanel, BoxLayout.Y_AXIS));
+        rightPanel.add(new JLabel("  "
+                + HTTPTracer.getMessage("response00", "Response")));
+        rightPanel.add(new JLabel(""));
+        outPane = new JSplitPane(0, leftPanel, rightPanel);
+        outPane.setDividerSize(4);
+        pane2.add(outPane, BorderLayout.CENTER);
+        JPanel bottomButtons = new JPanel();
+        bottomButtons.setLayout(new BoxLayout(bottomButtons,
+                BoxLayout.X_AXIS));
+        bottomButtons.setBorder(BorderFactory.createEmptyBorder(5, 5, 5,
+                5));
+        bottomButtons.add(
+                xmlFormatBox =
+                new JCheckBox(HTTPTracer.getMessage("xmlFormat00", "XML Format")));
+        bottomButtons.add(Box.createRigidArea(new Dimension(5, 0)));
+        final String save = HTTPTracer.getMessage("save00", "Save");
+        bottomButtons.add(saveButton = new JButton(save));
+        bottomButtons.add(Box.createRigidArea(new Dimension(5, 0)));
+        final String resend = HTTPTracer.getMessage("resend00", "Resend");
+        bottomButtons.add(resendButton = new JButton(resend));
+        bottomButtons.add(Box.createRigidArea(new Dimension(5, 0)));
+        final String switchStr = HTTPTracer.getMessage("switch00", "Switch Layout");
+        bottomButtons.add(switchButton = new JButton(switchStr));
+        bottomButtons.add(Box.createHorizontalGlue());
+        final String close = HTTPTracer.getMessage("close00", "Close");
+        bottomButtons.add(closeButton = new JButton(close));
+        pane2.add(bottomButtons, BorderLayout.SOUTH);
+        saveButton.setEnabled(false);
+        saveButton.addActionListener(new ActionListener() {
+            public void actionPerformed(ActionEvent event) {
+                if (save.equals(event.getActionCommand())) {
+                    save();
+                }
+            }
+        });
+        resendButton.setEnabled(false);
+        resendButton.addActionListener(new ActionListener() {
+            public void actionPerformed(ActionEvent event) {
+                if (resend.equals(event.getActionCommand())) {
+                    resend();
+                }
+            }
+        });
+        switchButton.addActionListener(new ActionListener() {
+            public void actionPerformed(ActionEvent event) {
+                if (switchStr.equals(event.getActionCommand())) {
+                    int v = outPane.getOrientation();
+                    if (v == 0) {
+
+                        // top/bottom
+                        outPane.setOrientation(1);
+                    } else {
+
+                        // left/right
+                        outPane.setOrientation(0);
+                    }
+                    outPane.setDividerLocation(0.5);
+                }
+            }
+        });
+        closeButton.addActionListener(new ActionListener() {
+            public void actionPerformed(ActionEvent event) {
+                if (close.equals(event.getActionCommand())) {
+                    close();
+                }
+            }
+        });
+        JSplitPane pane1 = new JSplitPane(0);
+        pane1.setDividerSize(4);
+        pane1.setTopComponent(tablePane);
+        pane1.setBottomComponent(pane2);
+        pane1.setDividerLocation(150);
+        this.add(pane1, BorderLayout.CENTER);
+
+        // 
+        // //////////////////////////////////////////////////////////////////
+        sel.setSelectionInterval(0, 0);
+        outPane.setDividerLocation(150);
+        notebook.addTab(name, this);
+        start();
+    }
+
+    /**
+     * Method setLeft
+     *
+     * @param left
+     */
+    public void setLeft(Component left) {
+        leftPanel.removeAll();
+        leftPanel.add(left);
+    }
+
+    /**
+     * Method setRight
+     *
+     * @param right
+     */
+    public void setRight(Component right) {
+        rightPanel.removeAll();
+        rightPanel.add(right);
+    }
+
+    /**
+     * Method start
+     */
+    public void start() {
+        int port = Integer.parseInt(portField.getText());
+        portField.setText("" + port);
+        int i = notebook.indexOfComponent(this);
+        notebook.setTitleAt(i, HTTPTracer.getMessage("port01", "Port") + " " + port);
+        int tmp = Integer.parseInt(tPortField.getText());
+        tPortField.setText("" + tmp);
+        sw = new SocketWaiter(this, port);
+        stopButton.setText(HTTPTracer.getMessage("stop00", "Stop"));
+        portField.setEditable(false);
+        hostField.setEditable(false);
+        tPortField.setEditable(false);
+        isProxyBox.setEnabled(false);
+    }
+
+    /**
+     * Method close
+     */
+    public void close() {
+        stop();
+        notebook.remove(this);
+    }
+
+    /**
+     * Method stop
+     */
+    public void stop() {
+        try {
+            for (int i = 0; i < connections.size(); i++) {
+                Connection conn = (Connection) connections.get(i);
+                conn.halt();
+            }
+            sw.halt();
+            stopButton.setText(HTTPTracer.getMessage("start00", "Start"));
+            portField.setEditable(true);
+            hostField.setEditable(true);
+            tPortField.setEditable(true);
+            isProxyBox.setEnabled(true);
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+
+    /**
+     * Method remove
+     */
+    public void remove() {
+        ListSelectionModel lsm = connectionTable.getSelectionModel();
+        int bot = lsm.getMinSelectionIndex();
+        int top = lsm.getMaxSelectionIndex();
+        for (int i = top; i >= bot; i--) {
+            ((Connection) connections.get(i - 1)).remove();
+        }
+        if (bot > connections.size()) {
+            bot = connections.size();
+        }
+        lsm.setSelectionInterval(bot, bot);
+    }
+
+    /**
+     * Method removeAll
+     */
+    public void removeAll() {
+        ListSelectionModel lsm = connectionTable.getSelectionModel();
+        lsm.clearSelection();
+        while (connections.size() > 0) {
+            ((Connection) connections.get(0)).remove();
+        }
+        lsm.setSelectionInterval(0, 0);
+    }
+
+    /**
+     * Method save
+     */
+    public void save() {
+        JFileChooser dialog = new JFileChooser(".");
+        int rc = dialog.showSaveDialog(this);
+        if (rc == JFileChooser.APPROVE_OPTION) {
+            try {
+                File file = dialog.getSelectedFile();
+                FileOutputStream out = new FileOutputStream(file);
+                ListSelectionModel lsm =
+                        connectionTable.getSelectionModel();
+                rc = lsm.getLeadSelectionIndex();
+                int n = 0;
+                for (Iterator i = connections.iterator(); i.hasNext();
+                     n++) {
+                    Connection conn = (Connection) i.next();
+                    if (lsm.isSelectedIndex(n + 1)
+                            || (!(i.hasNext())
+                            && (lsm.getLeadSelectionIndex() == 0))) {
+                        rc = Integer.parseInt(portField.getText());
+                        out.write("\n==============\n".getBytes());
+                        out.write(((HTTPTracer.getMessage("listenPort01",
+                                "Listen Port:")
+                                + " " + rc + "\n")).getBytes());
+                        out.write((HTTPTracer.getMessage("targetHost01",
+                                "Target Host:")
+                                + " " + hostField.getText()
+                                + "\n").getBytes());
+                        rc = Integer.parseInt(tPortField.getText());
+                        out.write(((HTTPTracer.getMessage("targetPort01",
+                                "Target Port:")
+                                + " " + rc + "\n")).getBytes());
+                        out.write((("==== "
+                                + HTTPTracer.getMessage("request01", "Request")
+                                + " ====\n")).getBytes());
+                        out.write(conn.inputText.getText().getBytes());
+                        out.write((("==== "
+                                + HTTPTracer.getMessage("response00", "Response")
+                                + " ====\n")).getBytes());
+                        out.write(conn.outputText.getText().getBytes());
+                        out.write("\n==============\n".getBytes());
+                    }
+                }
+                out.close();
+            } catch (Exception e) {
+                e.printStackTrace();
+            }
+        }
+    }
+
+    /**
+     * Method resend
+     */
+    public void resend() {
+        int rc;
+        try {
+            ListSelectionModel lsm = connectionTable.getSelectionModel();
+            rc = lsm.getLeadSelectionIndex();
+            if (rc == 0) {
+                rc = connections.size();
+            }
+            Connection conn = (Connection) connections.get(rc - 1);
+            if (rc > 0) {
+                lsm.clearSelection();
+                lsm.setSelectionInterval(0, 0);
+            }
+            InputStream in = null;
+            String text = conn.inputText.getText();
+
+            // Fix Content-Length HTTP headers
+            if (text.startsWith("POST ") || text.startsWith("GET ")) {
+
+                // System.err.println("IN CL" );
+                int pos1, pos2, pos3;
+                String headers;
+                pos3 = text.indexOf("\n\n");
+                if (pos3 == -1) {
+                    pos3 = text.indexOf("\r\n\r\n");
+                    if (pos3 != -1) {
+                        pos3 = pos3 + 4;
+                    }
+                } else {
+                    pos3 += 2;
+                }
+                headers = text.substring(0, pos3);
+                pos1 = headers.indexOf("Content-Length:");
+
+                // System.err.println("pos1: " + pos1 );
+                // System.err.println("pos3: " + pos3 );
+                if (pos1 != -1) {
+                    int newLen = text.length() - pos3;
+                    pos2 = headers.indexOf("\n", pos1);
+                    System.err.println("CL: " + newLen);
+                    System.err.println("Hdrs: '" + headers + "'");
+                    System.err.println("subTEXT: '"
+                            + text.substring(pos3, pos3 + newLen)
+                            + "'");
+                    text = headers.substring(0, pos1) + "Content-Length: "
+                            + newLen + "\n" + headers.substring(pos2 + 1)
+                            + text.substring(pos3);
+                    System.err.println("\nTEXT: '" + text + "'");
+                }
+            }
+            in = new ByteArrayInputStream(text.getBytes());
+            new Connection(this, in);
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+}

Added: webservices/axis2/trunk/java/modules/tool/src/org/apache/axis2/tool/tracer/SlowLinkSimulator.java
URL: http://svn.apache.org/viewcvs/webservices/axis2/trunk/java/modules/tool/src/org/apache/axis2/tool/tracer/SlowLinkSimulator.java?rev=289655&view=auto
==============================================================================
--- webservices/axis2/trunk/java/modules/tool/src/org/apache/axis2/tool/tracer/SlowLinkSimulator.java (added)
+++ webservices/axis2/trunk/java/modules/tool/src/org/apache/axis2/tool/tracer/SlowLinkSimulator.java Fri Sep 16 14:30:29 2005
@@ -0,0 +1,124 @@
+/*
+ * Copyright 2004,2005 The Apache Software Foundation.
+ *
+ * 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.apache.axis2.tool.tracer;
+
+/**
+ * class to simulate slow connections by slowing down the system
+ */
+class SlowLinkSimulator {
+
+	/**
+     * Field delayBytes
+     */
+    private int delayBytes;
+
+    /**
+     * Field delayTime
+     */
+    private int delayTime;
+
+    /**
+     * Field currentBytes
+     */
+    private int currentBytes;
+
+    /**
+     * Field totalBytes
+     */
+    private int totalBytes;
+
+    /**
+     * construct
+     *
+     * @param delayBytes bytes per delay; set to 0 for no delay
+     * @param delayTime  delay time per delay in milliseconds
+     */
+    public SlowLinkSimulator(int delayBytes, int delayTime) {
+        this.delayBytes = delayBytes;
+        this.delayTime = delayTime;
+    }
+
+    /**
+     * construct by copying delay bytes and time, but not current
+     * count of bytes
+     *
+     * @param that source of data
+     */
+    public SlowLinkSimulator(SlowLinkSimulator that) {
+        this.delayBytes = that.delayBytes;
+        this.delayTime = that.delayTime;
+    }
+
+    /**
+     * how many bytes have gone past?
+     *
+     * @return integer
+     */
+    public int getTotalBytes() {
+        return totalBytes;
+    }
+
+    /**
+     * log #of bytes pumped. Will pause when necessary. This method is not
+     * synchronized
+     *
+     * @param bytes
+     */
+    public void pump(int bytes) {
+        totalBytes += bytes;
+        if (delayBytes == 0) {
+
+            // when not delaying, we are just a byte counter
+            return;
+        }
+        currentBytes += bytes;
+        if (currentBytes > delayBytes) {
+
+            // we have overshot. lets find out how far
+            int delaysize = currentBytes / delayBytes;
+            long delay = delaysize * (long) delayTime;
+
+            // move byte counter down to the remainder of bytes
+            currentBytes = currentBytes % delayBytes;
+
+            // now wait
+            try {
+                Thread.sleep(delay);
+            } catch (InterruptedException e) {
+                ;    // ignore the exception
+            }
+        }
+    }
+
+    /**
+     * get the current byte count
+     *
+     * @return integer
+     */
+    public int getCurrentBytes() {
+        return currentBytes;
+    }
+
+    /**
+     * set the current byte count
+     *
+     * @param currentBytes
+     */
+    public void setCurrentBytes(int currentBytes) {
+        this.currentBytes = currentBytes;
+    }
+}



Mime
View raw message