java/internal/testidle.java

/*
 * Copyright (c) 1997-2010 Oracle and/or its affiliates. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 *   - Redistributions of source code must retain the above copyright
 *     notice, this list of conditions and the following disclaimer.
 *
 *   - Redistributions in binary form must reproduce the above copyright
 *     notice, this list of conditions and the following disclaimer in the
 *     documentation and/or other materials provided with the distribution.
 *
 *   - Neither the name of Oracle nor the names of its
 *     contributors may be used to endorse or promote products derived
 *     from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
 * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR
 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

import java.util.*;
import java.util.concurrent.atomic.*;
import java.io.*;
import javax.mail.*;
import javax.mail.event.*;
import javax.mail.internet.*;
import javax.activation.*;

import com.sun.mail.imap.*;

/**
 * Test program for IDLE support in IMAP provider.
 *
 * Run several threads that access the folder's connection
 * while another thread runs the IDLE command.  A timer
 * thread checks that each thread is making progress, to
 * detect deadlock.
 *
 * XXX - Should have another thread add messages to the folder
 *   to test the new message notification works properly.
 */
public class testidle {

    public static Store store;
    public static Folder folder;
    public static boolean showStructure = false;
    public static boolean saveAttachments = false;
    public static int attnum = 0;
    public static int totalTime;

    public static final AtomicBoolean stop = new AtomicBoolean(false);
    public static final AtomicInteger folderProgress = new AtomicInteger();
    public static final AtomicInteger msgProgress = new AtomicInteger();

    public static void main(String argv[]) {
    if (argv.length != 5) {
        System.out.println(
        "Usage: testidle <host> <user> <password> <mbox> <time>");
        System.exit(1);
    }

        try {
        Properties props = System.getProperties();

        // Get a Session object
        Session session = Session.getInstance(props, null);
        // session.setDebug(true);

        // Get a Store object
        store = session.getStore("imap");

        store.addStoreListener(new StoreListener() {
        public void notification(StoreEvent e) {
            System.out.println("StoreEvent: type " +
            e.getMessageType() + ", message " +
            e.getMessage());
        }
        });

        // Connect
        store.connect(argv[0], argv[1], argv[2]);

        // Open a Folder
        folder = store.getFolder(argv[3]);
        if (folder == null || !folder.exists()) {
        System.out.println("Invalid folder");
        System.exit(1);
        }

        folder.open(Folder.READ_WRITE);

        // Add messageCountListener to listen for new messages
        folder.addMessageCountListener(new MessageCountAdapter() {
        public void messagesAdded(MessageCountEvent ev) {
            Message[] msgs = ev.getMessages();
            System.out.println("Got " + msgs.length + " new messages");

            // Just dump out the new messages
            for (int i = 0; i < msgs.length; i++) {
            try {
                System.out.println("-----");
                System.out.println("Message " +
                msgs[i].getMessageNumber() + ":");
                msgs[i].writeTo(System.out);
            } catch (IOException ioex) {
                ioex.printStackTrace();
            } catch (MessagingException mex) {
                mex.printStackTrace();
            }
            }
        }
        });

        totalTime = Integer.parseInt(argv[4]);

        new Thread("timer") {
        public void run() {
            timer();
        }
        }.start();

        new Thread("message reader") {
        public void run() {
            readMessages();
        }
        }.start();

        new Thread("folder reader") {
        public void run() {
            readFolder();
        }
        }.start();

        new Thread("store idle") {
        public void run() {
            storeIdle();
        }
        }.start();


        /*
         * make sure two threads running idle works properly
        new Thread("idle") {
        public void run() {
            try {
            doIdle();
            } catch (MessagingException mex) { }
        }
        }.start();
         */

        doIdle();

        System.out.println("connected " + store.isConnected());

    } catch (Exception ex) {
        ex.printStackTrace();
    }
    }

    /**
     * Run the idle command until told to stop.
     */
    public static void doIdle() throws MessagingException {
    boolean supportsIdle = false;
    try {
        if (folder instanceof IMAPFolder) {
        IMAPFolder f = (IMAPFolder)folder;
        f.idle();
        supportsIdle = true;
        }
    } catch (FolderClosedException fex) {
        throw fex;
    } catch (MessagingException mex) {
        supportsIdle = false;
    }
    while (!stop.get()) {
        if (supportsIdle && folder instanceof IMAPFolder) {
        IMAPFolder f = (IMAPFolder)folder;
        f.idle();
        /*
        System.out.println("IDLE done in " +
                    Thread.currentThread().getName());
         */
        } else {
        try {
            Thread.sleep(1000); // sleep for 1000 milliseconds
        } catch (InterruptedException ex) { }

        // This is to force the IMAP server to send us
        // EXISTS notifications.
        folder.getMessageCount();
        }
    }
    }

    /**
     * Monitor progress of threads and tell them to stop
     * when their time is up.
     */
    public static void timer() {
    long tend = System.currentTimeMillis() + totalTime;
    int fpcnt = folderProgress.get();
    int mpcnt = msgProgress.get();
    while (System.currentTimeMillis() < tend) {
        try {
        Thread.sleep(1000);
        } catch (InterruptedException ex) { }
        int nfpcnt = folderProgress.get();
        int nmpcnt = msgProgress.get();
        if (!(nfpcnt > fpcnt && nmpcnt > mpcnt)) {
        System.out.println("THREAD STUCK?");
        System.out.printf("fpcnt %d nfpcnt %d\n", fpcnt, nfpcnt);
        System.out.printf("mpcnt %d nmpcnt %d\n", mpcnt, nmpcnt);
        }
        fpcnt = nfpcnt;
        mpcnt = nmpcnt;
    }
    System.out.println("STOPPING");
    stop.set(true);
    try {
        folder.getUnreadMessageCount(); // force IDLE to terminate
    } catch (MessagingException mex) { }
    }

    /**
     * Read all the messages in the folder and access all their content.
     */
    public static void readMessages() {
    try {
        while (!stop.get()) {
        int cnt = folder.getMessageCount();
        for (int i = 1; i <= cnt; i++) {
            //System.out.println("dump " + i);
            Message msg = folder.getMessage(i);
            dumpEnvelope(msg);
            msgProgress.incrementAndGet();
            try {
            Thread.sleep(25);
            } catch (InterruptedException ex) { }
        }
        }
        System.out.println("messages DONE");
    } catch (Exception ex) {
        System.out.println(ex);
    }
    }

    /**
     * Perform folder commands to compete with the message
     * access commands.
     */
    public static void readFolder() {
    try {
        while (!stop.get()) {
        int cnt = folder.getUnreadMessageCount();
        store.isConnected();    // poke the store too
        folderProgress.incrementAndGet();
        try {
            Thread.sleep(100);
        } catch (InterruptedException ex) { }
        }
        System.out.println("folder DONE");
    } catch (MessagingException mex) {
        System.out.println(mex);
    }
    }

    /**
     * Run the idle command until told to stop.
     */
    public static void storeIdle() {
    boolean supportsIdle = false;
    try {
        if (store instanceof IMAPStore) {
        IMAPStore s = (IMAPStore)store;
        s.idle();
        supportsIdle = true;
        }
    } catch (MessagingException mex) {
        supportsIdle = false;
    }
    try {
        while (!stop.get()) {
        if (supportsIdle && store instanceof IMAPStore) {
            IMAPStore s = (IMAPStore)store;
            s.idle();
            /*
            */
            System.out.println("IDLE done in " +
                        Thread.currentThread().getName());
             /*
             */
        } else {
            try {
            Thread.sleep(1000); // sleep for 1000 milliseconds
            } catch (InterruptedException ex) { }
        }
        }
    } catch (MessagingException mex) {
        System.out.println(mex);
    }
    }

    /**
     * Dump contents of message part.
     * (Copied from msgshow.java)
     */
    public static void dumpPart(Part p) throws Exception {
    if (p instanceof Message)
        dumpEnvelope((Message)p);

    /** Dump input stream ..

    InputStream is = p.getInputStream();
    // If "is" is not already buffered, wrap a BufferedInputStream
    // around it.
    if (!(is instanceof BufferedInputStream))
        is = new BufferedInputStream(is);
    int c;
    while ((c = is.read()) != -1)
        System.out.write(c);

    **/

    String ct = p.getContentType();
    try {
        pr("CONTENT-TYPE: " + (new ContentType(ct)).toString());
    } catch (ParseException pex) {
        pr("BAD CONTENT-TYPE: " + ct);
    }
    String filename = p.getFileName();
    if (filename != null)
        pr("FILENAME: " + filename);

    /*
     * Using isMimeType to determine the content type avoids
     * fetching the actual content data until we need it.
     */
    if (p.isMimeType("text/plain")) {
        pr("This is plain text");
        pr("---------------------------");
        if (!showStructure && !saveAttachments)
        System.out.println((String)p.getContent());
    } else if (p.isMimeType("multipart/*")) {
        pr("This is a Multipart");
        pr("---------------------------");
        Multipart mp = (Multipart)p.getContent();
        level++;
        int count = mp.getCount();
        for (int i = 0; i < count; i++)
        dumpPart(mp.getBodyPart(i));
        level--;
    } else if (p.isMimeType("message/rfc822")) {
        pr("This is a Nested Message");
        pr("---------------------------");
        level++;
        dumpPart((Part)p.getContent());
        level--;
    } else {
        if (!showStructure && !saveAttachments) {
        /*
         * If we actually want to see the data, and it's not a
         * MIME type we know, fetch it and check its Java type.
         */
        Object o = p.getContent();
        if (o instanceof String) {
            pr("This is a string");
            pr("---------------------------");
            System.out.println((String)o);
        } else if (o instanceof InputStream) {
            pr("This is just an input stream");
            pr("---------------------------");
            InputStream is = (InputStream)o;
            int c;
            while ((c = is.read()) != -1)
            System.out.write(c);
        } else {
            pr("This is an unknown type");
            pr("---------------------------");
            pr(o.toString());
        }
        } else {
        // just a separator
        pr("---------------------------");
        }
    }

    /*
     * If we're saving attachments, write out anything that
     * looks like an attachment into an appropriately named
     * file.  Don't overwrite existing files to prevent
     * mistakes.
     */
    if (saveAttachments && level != 0 && !p.isMimeType("multipart/*")) {
        String disp = p.getDisposition();
        // many mailers don't include a Content-Disposition
        if (disp == null || disp.equalsIgnoreCase(Part.ATTACHMENT)) {
        if (filename == null)
            filename = "Attachment" + attnum++;
        pr("Saving attachment to file " + filename);
        try {
            File f = new File(filename);
            if (f.exists())
            // XXX - could try a series of names
            throw new IOException("file exists");
            ((MimeBodyPart)p).saveFile(f);
        } catch (IOException ex) {
            pr("Failed to save attachment: " + ex);
        }
        pr("---------------------------");
        }
    }
    }

    public static void dumpEnvelope(Message m) throws Exception {
    pr("This is the message envelope");
    pr("---------------------------");
    Address[] a;
    // FROM
    if ((a = m.getFrom()) != null) {
        for (int j = 0; j < a.length; j++)
        pr("FROM: " + a[j].toString());
    }

    // TO
    if ((a = m.getRecipients(Message.RecipientType.TO)) != null) {
        for (int j = 0; j < a.length; j++) {
        pr("TO: " + a[j].toString());
        InternetAddress ia = (InternetAddress)a[j];
        if (ia.isGroup()) {
            InternetAddress[] aa = ia.getGroup(false);
            for (int k = 0; k < aa.length; k++)
            pr("  GROUP: " + aa[k].toString());
        }
        }
    }

    // SUBJECT
    pr("SUBJECT: " + m.getSubject());

    // DATE
    Date d = m.getSentDate();
    pr("SendDate: " +
        (d != null ? d.toString() : "UNKNOWN"));

    // FLAGS
    Flags flags = m.getFlags();
    StringBuffer sb = new StringBuffer();
    Flags.Flag[] sf = flags.getSystemFlags(); // get the system flags

    boolean first = true;
    for (int i = 0; i < sf.length; i++) {
        String s;
        Flags.Flag f = sf[i];
        if (f == Flags.Flag.ANSWERED)
        s = "\\Answered";
        else if (f == Flags.Flag.DELETED)
        s = "\\Deleted";
        else if (f == Flags.Flag.DRAFT)
        s = "\\Draft";
        else if (f == Flags.Flag.FLAGGED)
        s = "\\Flagged";
        else if (f == Flags.Flag.RECENT)
        s = "\\Recent";
        else if (f == Flags.Flag.SEEN)
        s = "\\Seen";
        else
        continue;   // skip it
        if (first)
        first = false;
        else
        sb.append(' ');
        sb.append(s);
    }

    String[] uf = flags.getUserFlags(); // get the user flag strings
    for (int i = 0; i < uf.length; i++) {
        if (first)
        first = false;
        else
        sb.append(' ');
        sb.append(uf[i]);
    }
    pr("FLAGS: " + sb.toString());

    // X-MAILER
    String[] hdrs = m.getHeader("X-Mailer");
    if (hdrs != null)
        pr("X-Mailer: " + hdrs[0]);
    else
        pr("X-Mailer NOT available");
    }

    static String indentStr = "                                               ";
    static int level = 0;

    /**
     * Print a, possibly indented, string.
     */
    public static void pr(String s) {
    /*
    if (showStructure)
        System.out.print(indentStr.substring(0, level * 2));
    System.out.println(s);
    */
    }
}