src.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-jdk8 Show documentation
Show all versions of jt400-jdk8 Show documentation
The Open Source version of the IBM Toolbox for Java
///////////////////////////////////////////////////////////////////////////////
//
// 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;
}
}