com.ibm.as400.util.commtrace.Read Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of jt400 Show documentation
The Open Source version of the IBM Toolbox for Java
There is a newer version: 20.0.8
///////////////////////////////////////////////////////////////////////////////
//                                                                             
// JTOpen (IBM Toolbox for Java - OSS version)                                 
//                                                                             
// Filename: Read.java
//                                                                             
// The source code contained herein is licensed under the IBM Public License   
// Version 1.0, which has been approved by the Open Source Initiative.         
// Copyright (C) 2002 International Business Machines Corporation and     
// others. All rights reserved.                                                
//                                                                             
///////////////////////////////////////////////////////////////////////////////

package com.ibm.as400.util.commtrace;

import com.ibm.as400.access.AS400;
import com.ibm.as400.access.AS400SecurityException;
import com.ibm.as400.access.IFSFileInputStream;
import com.ibm.as400.access.Trace;
import java.io.BufferedOutputStream;
import java.io.FileOutputStream;
import java.io.File;
import java.io.IOException;
import javax.swing.JOptionPane;

/**
 * The Read class is used to read an IFS file down from an IBM i system and store it 
 * in the local PC.

 * A Progress Dialog is displayed and updated so the user is kept current as to
 * the progression of the download.
 */
class Read implements Runnable {

	private String rmtfile, // The remote file to download
	lclfile; // The local file to save to
	private AS400 sys; // The system to connect to
	private CommTrace comm; // The commtrace object so we manage our thread
	private Progress pro; // The progress Dialog
	private Thread proThread; // The progress dialog thread
	// The tread to transfer a file to the local PC
	private Thread readThread_= null;
	private int bytes= 0; // The number of bytes read

	private static final String CLASS = "Read";

	/**
	 * Creates a read object which will open an IFSFileStream on the remote file
	 * from the given system and read into the local file.
	 * @param comm 
	 * @param rmtfile   Path of the remote file to download
	 * @param lclfile   Path of the local file to save to
	 * @param sys	    The system to connect to
	 */
	public Read(CommTrace comm, String rmtfile, String lclfile, AS400 sys) {
		this.comm= comm;
		this.rmtfile= rmtfile;
		this.lclfile= lclfile;
		this.sys= sys;
	}

	/**
	 * Transfers the file to the local PC.
	 */
	public void run() {
		byte[] tmp= null;
		int len= 0;
		bytes= 0;
		Thread myThread= Thread.currentThread();

		while (readThread_ == myThread) {
			IFSFileInputStream file= null;
			BufferedOutputStream out= null;
			try {
				file= new IFSFileInputStream(sys, rmtfile);
				out= new BufferedOutputStream(new FileOutputStream(lclfile));
				pro= new Progress(("Retrieving " + rmtfile), file.available(), " bytes");
				proThread= new Thread(pro, "ProgDiag");
				proThread.start();

				int filesize= file.available();
				if (Trace.isTraceOn() && Trace.isTraceInformationOn()) {
					Trace.log(Trace.INFORMATION,CLASS + ".run() " + "Transfer file size:" + filesize);
				}

				int selection=
					JOptionPane.showConfirmDialog(
						CommTrace.getMainFrame(),
						"Start transfer of " + rmtfile + "(" + (filesize / 1024) + " KB)?",
						"Transfer",
						JOptionPane.YES_NO_OPTION);
				if (selection == 1) { // The user cancled the download
					return;
				} else if (selection == 0) { // The user okayed the download				
					byte[] data= new byte[4096];

					// Read while there is data, the Progress dialog isn't cancled, 
					// and the thread is still running 
					while ((len= file.read(data)) != -1
						&& !pro.isCanceled()
						&& readThread_ != null) {
						// Create an array the size of our read. 
						tmp= new byte[len];
						// Copy from input buffer to tmp buffer
						System.arraycopy(data, 0, tmp, 0, len);
						// Write tmp to file.
						out.write(tmp);
						// Increment the total byte counter
						bytes += len;
						pro.updateProgress(bytes);
					}
					// The transfer was canceled so delete the file
					if (pro.isCanceled() || readThread_ == null) {
						file.close();
						out.close();
						File local= new File(lclfile);
						if (local.exists()) {
							local.delete();
						}
					}
				}
			} catch (IOException e) {
				CommTrace.error("File Error", "Error reading/writing file");
			} catch (AS400SecurityException e) {
				CommTrace.error("Security Error", "Security problem opening file");
			}
			if (!pro.isCanceled() && readThread_ != null) {
				if (Trace.isTraceOn() && Trace.isTraceInformationOn()) {
					Trace.log(Trace.INFORMATION,CLASS + ".run() " + "Transfering completed");
				}
				JOptionPane.showMessageDialog(
					CommTrace.getMainFrame(),
					"Transfer of " + rmtfile + " completed",
					"Transfer Complete",
					JOptionPane.INFORMATION_MESSAGE);
			}
			readThread_= null; // Tell everyone we are done

			try {
				file.close();
				out.close();
			} catch (IOException e) {
				CommTrace.error("File Error", "Error closing file");
			} catch (NullPointerException e) {
			}
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				// the VM doesn't want us to sleep anymore,
				// so get back to work
			}
		}
	}

	/**
	 * Returns the number of bytes that have been read off this stream.
	 * @return The number of bytes
	 */
	public int getBytesRead() {
		return bytes;
	}

	/**
	 * Returns the thread that this read process is executing under.
	 * @return Threads
	
	 */
	public Thread getThread() {
		return readThread_;
	}

	/**
	 * Sets the thread this process is executing under.
	 * @param thread The thread to execute under
	 */
	public void setThread(Thread thread) {
		readThread_= thread;
	}
}