mirror of
https://codeberg.org/Mercury-IM/Smack
synced 2025-12-09 22:51:07 +01:00
smack_1_5_1
git-svn-id: http://svn.igniterealtime.org/svn/repos/smack/trunk@2639 b35dd754-fafc-0310-a699-88a17e54d16e
This commit is contained in:
Gaston Dombiak
gato
parent
aa32e12164
commit
7ae75258be
276 changed files with 40430 additions and 0 deletions
|
|
@ -0,0 +1,145 @@
|
|||
package org.jivesoftware.smack.debugger;
|
||||
|
||||
import org.jivesoftware.smack.ConnectionListener;
|
||||
import org.jivesoftware.smack.PacketListener;
|
||||
import org.jivesoftware.smack.XMPPConnection;
|
||||
import org.jivesoftware.smack.packet.Packet;
|
||||
import org.jivesoftware.smack.util.*;
|
||||
|
||||
import java.io.Reader;
|
||||
import java.io.Writer;
|
||||
import java.text.SimpleDateFormat;
|
||||
import java.util.Date;
|
||||
|
||||
/**
|
||||
* Very simple debugger that prints to the console (stdout) the sent and received stanzas. Use
|
||||
* this debugger with caution since printing to the console is an expensive operation that may
|
||||
* even block the thread since only one thread may print at a time.<p>
|
||||
* <p/>
|
||||
* It is possible to not only print the raw sent and received stanzas but also the interpreted
|
||||
* packets by Smack. By default interpreted packets won't be printed. To enable this feature
|
||||
* just change the <tt>printInterpreted</tt> static variable to <tt>true</tt>.
|
||||
*
|
||||
* @author Gaston Dombiak
|
||||
*/
|
||||
public class ConsoleDebugger implements SmackDebugger {
|
||||
|
||||
public static boolean printInterpreted = false;
|
||||
private SimpleDateFormat dateFormatter = new SimpleDateFormat("hh:mm:ss aaa");
|
||||
|
||||
private XMPPConnection connection = null;
|
||||
|
||||
private PacketListener listener = null;
|
||||
private ConnectionListener connListener = null;
|
||||
|
||||
private Writer writer;
|
||||
private Reader reader;
|
||||
private ReaderListener readerListener;
|
||||
private WriterListener writerListener;
|
||||
|
||||
public ConsoleDebugger(XMPPConnection connection, Writer writer, Reader reader) {
|
||||
this.connection = connection;
|
||||
this.writer = writer;
|
||||
this.reader = reader;
|
||||
createDebug();
|
||||
}
|
||||
|
||||
/**
|
||||
* Creates the listeners that will print in the console when new activity is detected.
|
||||
*/
|
||||
private void createDebug() {
|
||||
// Create a special Reader that wraps the main Reader and logs data to the GUI.
|
||||
ObservableReader debugReader = new ObservableReader(reader);
|
||||
readerListener = new ReaderListener() {
|
||||
public void read(String str) {
|
||||
System.out.println(
|
||||
dateFormatter.format(new Date()) + " RCV (" + connection.hashCode() +
|
||||
"): " +
|
||||
str);
|
||||
}
|
||||
};
|
||||
debugReader.addReaderListener(readerListener);
|
||||
|
||||
// Create a special Writer that wraps the main Writer and logs data to the GUI.
|
||||
ObservableWriter debugWriter = new ObservableWriter(writer);
|
||||
writerListener = new WriterListener() {
|
||||
public void write(String str) {
|
||||
System.out.println(
|
||||
dateFormatter.format(new Date()) + " SENT (" + connection.hashCode() +
|
||||
"): " +
|
||||
str);
|
||||
}
|
||||
};
|
||||
debugWriter.addWriterListener(writerListener);
|
||||
|
||||
// Assign the reader/writer objects to use the debug versions. The packet reader
|
||||
// and writer will use the debug versions when they are created.
|
||||
reader = debugReader;
|
||||
writer = debugWriter;
|
||||
|
||||
// Create a thread that will listen for all incoming packets and write them to
|
||||
// the GUI. This is what we call "interpreted" packet data, since it's the packet
|
||||
// data as Smack sees it and not as it's coming in as raw XML.
|
||||
listener = new PacketListener() {
|
||||
public void processPacket(Packet packet) {
|
||||
if (printInterpreted) {
|
||||
System.out.println(
|
||||
dateFormatter.format(new Date()) + " RCV PKT (" +
|
||||
connection.hashCode() +
|
||||
"): " +
|
||||
packet.toXML());
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
connListener = new ConnectionListener() {
|
||||
public void connectionClosed() {
|
||||
System.out.println(
|
||||
dateFormatter.format(new Date()) + " Connection closed (" +
|
||||
connection.hashCode() +
|
||||
")");
|
||||
}
|
||||
|
||||
public void connectionClosedOnError(Exception e) {
|
||||
System.out.println(
|
||||
dateFormatter.format(new Date()) +
|
||||
" Connection closed due to an exception (" +
|
||||
connection.hashCode() +
|
||||
")");
|
||||
e.printStackTrace();
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
public void userHasLogged(String user) {
|
||||
boolean isAnonymous = "".equals(StringUtils.parseName(user));
|
||||
String title =
|
||||
"User logged (" + connection.hashCode() + "): "
|
||||
+ (isAnonymous ? "" : StringUtils.parseBareAddress(user))
|
||||
+ "@"
|
||||
+ connection.getHost()
|
||||
+ ":"
|
||||
+ connection.getPort();
|
||||
title += "/" + StringUtils.parseResource(user);
|
||||
System.out.println(title);
|
||||
// Add the connection listener to the connection so that the debugger can be notified
|
||||
// whenever the connection is closed.
|
||||
connection.addConnectionListener(connListener);
|
||||
}
|
||||
|
||||
public Reader getReader() {
|
||||
return reader;
|
||||
}
|
||||
|
||||
public Writer getWriter() {
|
||||
return writer;
|
||||
}
|
||||
|
||||
public PacketListener getReaderListener() {
|
||||
return listener;
|
||||
}
|
||||
|
||||
public PacketListener getWriterListener() {
|
||||
return null;
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,320 @@
|
|||
/**
|
||||
* $RCSfile$
|
||||
* $Revision$
|
||||
* $Date$
|
||||
*
|
||||
* Copyright 2003-2004 Jive Software.
|
||||
*
|
||||
* All rights reserved. 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.jivesoftware.smack.debugger;
|
||||
|
||||
import java.awt.*;
|
||||
import java.awt.datatransfer.*;
|
||||
import java.awt.event.*;
|
||||
import java.io.*;
|
||||
|
||||
import javax.swing.*;
|
||||
|
||||
import org.jivesoftware.smack.*;
|
||||
import org.jivesoftware.smack.packet.*;
|
||||
import org.jivesoftware.smack.util.*;
|
||||
|
||||
/**
|
||||
* The LiteDebugger is a very simple debugger that allows to debug sent, received and
|
||||
* interpreted messages.
|
||||
*
|
||||
* @author Gaston Dombiak
|
||||
*/
|
||||
public class LiteDebugger implements SmackDebugger {
|
||||
|
||||
private static final String NEWLINE = "\n";
|
||||
|
||||
private JFrame frame = null;
|
||||
private XMPPConnection connection = null;
|
||||
|
||||
private PacketListener listener = null;
|
||||
|
||||
private Writer writer;
|
||||
private Reader reader;
|
||||
private ReaderListener readerListener;
|
||||
private WriterListener writerListener;
|
||||
|
||||
public LiteDebugger(XMPPConnection connection, Writer writer, Reader reader) {
|
||||
this.connection = connection;
|
||||
this.writer = writer;
|
||||
this.reader = reader;
|
||||
createDebug();
|
||||
}
|
||||
|
||||
/**
|
||||
* Creates the debug process, which is a GUI window that displays XML traffic.
|
||||
*/
|
||||
private void createDebug() {
|
||||
frame = new JFrame("Smack Debug Window -- " + connection.getHost() + ":" +
|
||||
connection.getPort());
|
||||
|
||||
// Add listener for window closing event
|
||||
frame.addWindowListener(new WindowAdapter() {
|
||||
public void windowClosing(WindowEvent evt) {
|
||||
rootWindowClosing(evt);
|
||||
}
|
||||
});
|
||||
|
||||
// We'll arrange the UI into four tabs. The first tab contains all data, the second
|
||||
// client generated XML, the third server generated XML, and the fourth is packet
|
||||
// data from the server as seen by Smack.
|
||||
JTabbedPane tabbedPane = new JTabbedPane();
|
||||
|
||||
JPanel allPane = new JPanel();
|
||||
allPane.setLayout(new GridLayout(3, 1));
|
||||
tabbedPane.add("All", allPane);
|
||||
|
||||
// Create UI elements for client generated XML traffic.
|
||||
final JTextArea sentText1 = new JTextArea();
|
||||
final JTextArea sentText2 = new JTextArea();
|
||||
sentText1.setEditable(false);
|
||||
sentText2.setEditable(false);
|
||||
sentText1.setForeground(new Color(112, 3, 3));
|
||||
sentText2.setForeground(new Color(112, 3, 3));
|
||||
allPane.add(new JScrollPane(sentText1));
|
||||
tabbedPane.add("Sent", new JScrollPane(sentText2));
|
||||
|
||||
// Add pop-up menu.
|
||||
JPopupMenu menu = new JPopupMenu();
|
||||
JMenuItem menuItem1 = new JMenuItem("Copy");
|
||||
menuItem1.addActionListener(new ActionListener() {
|
||||
public void actionPerformed(ActionEvent e) {
|
||||
// Get the clipboard
|
||||
Clipboard clipboard = Toolkit.getDefaultToolkit().getSystemClipboard();
|
||||
// Set the sent text as the new content of the clipboard
|
||||
clipboard.setContents(new StringSelection(sentText1.getText()), null);
|
||||
}
|
||||
});
|
||||
|
||||
JMenuItem menuItem2 = new JMenuItem("Clear");
|
||||
menuItem2.addActionListener(new ActionListener() {
|
||||
public void actionPerformed(ActionEvent e) {
|
||||
sentText1.setText("");
|
||||
sentText2.setText("");
|
||||
}
|
||||
});
|
||||
|
||||
// Add listener to the text area so the popup menu can come up.
|
||||
MouseListener popupListener = new PopupListener(menu);
|
||||
sentText1.addMouseListener(popupListener);
|
||||
sentText2.addMouseListener(popupListener);
|
||||
menu.add(menuItem1);
|
||||
menu.add(menuItem2);
|
||||
|
||||
// Create UI elements for server generated XML traffic.
|
||||
final JTextArea receivedText1 = new JTextArea();
|
||||
final JTextArea receivedText2 = new JTextArea();
|
||||
receivedText1.setEditable(false);
|
||||
receivedText2.setEditable(false);
|
||||
receivedText1.setForeground(new Color(6, 76, 133));
|
||||
receivedText2.setForeground(new Color(6, 76, 133));
|
||||
allPane.add(new JScrollPane(receivedText1));
|
||||
tabbedPane.add("Received", new JScrollPane(receivedText2));
|
||||
|
||||
// Add pop-up menu.
|
||||
menu = new JPopupMenu();
|
||||
menuItem1 = new JMenuItem("Copy");
|
||||
menuItem1.addActionListener(new ActionListener() {
|
||||
public void actionPerformed(ActionEvent e) {
|
||||
// Get the clipboard
|
||||
Clipboard clipboard = Toolkit.getDefaultToolkit().getSystemClipboard();
|
||||
// Set the sent text as the new content of the clipboard
|
||||
clipboard.setContents(new StringSelection(receivedText1.getText()), null);
|
||||
}
|
||||
});
|
||||
|
||||
menuItem2 = new JMenuItem("Clear");
|
||||
menuItem2.addActionListener(new ActionListener() {
|
||||
public void actionPerformed(ActionEvent e) {
|
||||
receivedText1.setText("");
|
||||
receivedText2.setText("");
|
||||
}
|
||||
});
|
||||
|
||||
// Add listener to the text area so the popup menu can come up.
|
||||
popupListener = new PopupListener(menu);
|
||||
receivedText1.addMouseListener(popupListener);
|
||||
receivedText2.addMouseListener(popupListener);
|
||||
menu.add(menuItem1);
|
||||
menu.add(menuItem2);
|
||||
|
||||
// Create UI elements for interpreted XML traffic.
|
||||
final JTextArea interpretedText1 = new JTextArea();
|
||||
final JTextArea interpretedText2 = new JTextArea();
|
||||
interpretedText1.setEditable(false);
|
||||
interpretedText2.setEditable(false);
|
||||
interpretedText1.setForeground(new Color(1, 94, 35));
|
||||
interpretedText2.setForeground(new Color(1, 94, 35));
|
||||
allPane.add(new JScrollPane(interpretedText1));
|
||||
tabbedPane.add("Interpreted", new JScrollPane(interpretedText2));
|
||||
|
||||
// Add pop-up menu.
|
||||
menu = new JPopupMenu();
|
||||
menuItem1 = new JMenuItem("Copy");
|
||||
menuItem1.addActionListener(new ActionListener() {
|
||||
public void actionPerformed(ActionEvent e) {
|
||||
// Get the clipboard
|
||||
Clipboard clipboard = Toolkit.getDefaultToolkit().getSystemClipboard();
|
||||
// Set the sent text as the new content of the clipboard
|
||||
clipboard.setContents(new StringSelection(interpretedText1.getText()), null);
|
||||
}
|
||||
});
|
||||
|
||||
menuItem2 = new JMenuItem("Clear");
|
||||
menuItem2.addActionListener(new ActionListener() {
|
||||
public void actionPerformed(ActionEvent e) {
|
||||
interpretedText1.setText("");
|
||||
interpretedText2.setText("");
|
||||
}
|
||||
});
|
||||
|
||||
// Add listener to the text area so the popup menu can come up.
|
||||
popupListener = new PopupListener(menu);
|
||||
interpretedText1.addMouseListener(popupListener);
|
||||
interpretedText2.addMouseListener(popupListener);
|
||||
menu.add(menuItem1);
|
||||
menu.add(menuItem2);
|
||||
|
||||
frame.getContentPane().add(tabbedPane);
|
||||
|
||||
frame.setSize(550, 400);
|
||||
frame.setVisible(true);
|
||||
|
||||
// Create a special Reader that wraps the main Reader and logs data to the GUI.
|
||||
ObservableReader debugReader = new ObservableReader(reader);
|
||||
readerListener = new ReaderListener() {
|
||||
public void read(String str) {
|
||||
int index = str.lastIndexOf(">");
|
||||
if (index != -1) {
|
||||
receivedText1.append(str.substring(0, index + 1));
|
||||
receivedText2.append(str.substring(0, index + 1));
|
||||
receivedText1.append(NEWLINE);
|
||||
receivedText2.append(NEWLINE);
|
||||
if (str.length() > index) {
|
||||
receivedText1.append(str.substring(index + 1));
|
||||
receivedText2.append(str.substring(index + 1));
|
||||
}
|
||||
}
|
||||
else {
|
||||
receivedText1.append(str);
|
||||
receivedText2.append(str);
|
||||
}
|
||||
}
|
||||
};
|
||||
debugReader.addReaderListener(readerListener);
|
||||
|
||||
// Create a special Writer that wraps the main Writer and logs data to the GUI.
|
||||
ObservableWriter debugWriter = new ObservableWriter(writer);
|
||||
writerListener = new WriterListener() {
|
||||
public void write(String str) {
|
||||
sentText1.append(str);
|
||||
sentText2.append(str);
|
||||
if (str.endsWith(">")) {
|
||||
sentText1.append(NEWLINE);
|
||||
sentText2.append(NEWLINE);
|
||||
}
|
||||
}
|
||||
};
|
||||
debugWriter.addWriterListener(writerListener);
|
||||
|
||||
// Assign the reader/writer objects to use the debug versions. The packet reader
|
||||
// and writer will use the debug versions when they are created.
|
||||
reader = debugReader;
|
||||
writer = debugWriter;
|
||||
|
||||
// Create a thread that will listen for all incoming packets and write them to
|
||||
// the GUI. This is what we call "interpreted" packet data, since it's the packet
|
||||
// data as Smack sees it and not as it's coming in as raw XML.
|
||||
listener = new PacketListener() {
|
||||
public void processPacket(Packet packet) {
|
||||
interpretedText1.append(packet.toXML());
|
||||
interpretedText2.append(packet.toXML());
|
||||
interpretedText1.append(NEWLINE);
|
||||
interpretedText2.append(NEWLINE);
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
/**
|
||||
* Notification that the root window is closing. Stop listening for received and
|
||||
* transmitted packets.
|
||||
*
|
||||
* @param evt the event that indicates that the root window is closing
|
||||
*/
|
||||
public void rootWindowClosing(WindowEvent evt) {
|
||||
connection.removePacketListener(listener);
|
||||
((ObservableReader)reader).removeReaderListener(readerListener);
|
||||
((ObservableWriter)writer).removeWriterListener(writerListener);
|
||||
}
|
||||
|
||||
/**
|
||||
* Listens for debug window popup dialog events.
|
||||
*/
|
||||
private class PopupListener extends MouseAdapter {
|
||||
JPopupMenu popup;
|
||||
|
||||
PopupListener(JPopupMenu popupMenu) {
|
||||
popup = popupMenu;
|
||||
}
|
||||
|
||||
public void mousePressed(MouseEvent e) {
|
||||
maybeShowPopup(e);
|
||||
}
|
||||
|
||||
public void mouseReleased(MouseEvent e) {
|
||||
maybeShowPopup(e);
|
||||
}
|
||||
|
||||
private void maybeShowPopup(MouseEvent e) {
|
||||
if (e.isPopupTrigger()) {
|
||||
popup.show(e.getComponent(), e.getX(), e.getY());
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public void userHasLogged(String user) {
|
||||
boolean isAnonymous = "".equals(StringUtils.parseName(user));
|
||||
String title =
|
||||
"Smack Debug Window -- "
|
||||
+ (isAnonymous ? "" : StringUtils.parseBareAddress(user))
|
||||
+ "@"
|
||||
+ connection.getHost()
|
||||
+ ":"
|
||||
+ connection.getPort();
|
||||
title += "/" + StringUtils.parseResource(user);
|
||||
frame.setTitle(title);
|
||||
}
|
||||
|
||||
public Reader getReader() {
|
||||
return reader;
|
||||
}
|
||||
|
||||
public Writer getWriter() {
|
||||
return writer;
|
||||
}
|
||||
|
||||
public PacketListener getReaderListener() {
|
||||
return listener;
|
||||
}
|
||||
|
||||
public PacketListener getWriterListener() {
|
||||
return null;
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,78 @@
|
|||
/**
|
||||
* $RCSfile$
|
||||
* $Revision$
|
||||
* $Date$
|
||||
*
|
||||
* Copyright 2003-2004 Jive Software.
|
||||
*
|
||||
* All rights reserved. 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.jivesoftware.smack.debugger;
|
||||
|
||||
import java.io.*;
|
||||
|
||||
import org.jivesoftware.smack.*;
|
||||
|
||||
/**
|
||||
* Interface that allows for implementing classes to debug XML traffic. That is a GUI window that
|
||||
* displays XML traffic.<p>
|
||||
*
|
||||
* Every implementation of this interface <b>must</b> have a public constructor with the following
|
||||
* arguments: XMPPConnection, Writer, Reader.
|
||||
*
|
||||
* @author Gaston Dombiak
|
||||
*/
|
||||
public interface SmackDebugger {
|
||||
|
||||
/**
|
||||
* Called when a user has logged in to the server. The user could be an anonymous user, this
|
||||
* means that the user would be of the form host/resource instead of the form
|
||||
* user@host/resource.
|
||||
*
|
||||
* @param user the user@host/resource that has just logged in
|
||||
*/
|
||||
public abstract void userHasLogged(String user);
|
||||
|
||||
/**
|
||||
* Returns the special Reader that wraps the main Reader and logs data to the GUI.
|
||||
*
|
||||
* @return the special Reader that wraps the main Reader and logs data to the GUI.
|
||||
*/
|
||||
public abstract Reader getReader();
|
||||
|
||||
/**
|
||||
* Returns the special Writer that wraps the main Writer and logs data to the GUI.
|
||||
*
|
||||
* @return the special Writer that wraps the main Writer and logs data to the GUI.
|
||||
*/
|
||||
public abstract Writer getWriter();
|
||||
|
||||
/**
|
||||
* Returns the thread that will listen for all incoming packets and write them to the GUI.
|
||||
* This is what we call "interpreted" packet data, since it's the packet data as Smack sees
|
||||
* it and not as it's coming in as raw XML.
|
||||
*
|
||||
* @return the PacketListener that will listen for all incoming packets and write them to
|
||||
* the GUI
|
||||
*/
|
||||
public abstract PacketListener getReaderListener();
|
||||
|
||||
/**
|
||||
* Returns the thread that will listen for all outgoing packets and write them to the GUI.
|
||||
*
|
||||
* @return the PacketListener that will listen for all sent packets and write them to
|
||||
* the GUI
|
||||
*/
|
||||
public abstract PacketListener getWriterListener();
|
||||
}
|
||||
|
|
@ -0,0 +1 @@
|
|||
<body>Core debugger functionality.</body>
|
||||
Loading…
Add table
Add a link
Reference in a new issue