Flex FTP Abort

Posted on February 11, 2011 by Wijnand

To properly close a transfer to the FTP server, you need to send an Abort command (see http://www.w3.org/Protocols/rfc959/4_FileTransfer.html (ABORT) ). Flex FTP doesn’t support this so I added some functionality to be able to send an abort.

First I added the Abort command to the Commands class:

public static const ABOR:String = "ABOR";

After that I added a new invoker to the invokers package, AbortInv.

The FTPInvoker class required a new public method to support the Abort command, which can be overridden by the specific implementations. In FTPInvoker I added an abort method like this:

/**
* Stops this Invoker from executing.
*/
public function abort():void {
// Some Invokers just don't need to do anything.
finalize();
}

There was only one invoker where I had to override the abort method to get things working correctly and that was the UploadInv class. Here I added the following code:

/**
* @inheritDoc
*/
override public function abort():void {
super.abort();
if(interval) clearInterval(interval);
if(sourceFile) sourceFile.close();
if(passiveSocket && passiveSocket.connected) passiveSocket.close();
}

After that it was a matter of updating the FTPClient class with an abort method to get the circle complete.

/**
* Aborts the previous FTP command.
*/
public function abort():void {
if(currentProcess) {
if(currentProcess is UploadInv) {
swallowNextResponse = true;
}
currentProcess.abort();
currentProcess = null;
}
invoke( new AbortInv(this) );
}

Unfortunately I also had to update handleData method in the FTPClient class a little bit, because aborting an upload would result into 2 (or more) resonses at once from the FTP server.
My handleData method now looks like this:

private function handleData (pEvt:ProgressEvent):void
{
processing = false;
var response:String = ctrlSocket.readUTFBytes(ctrlSocket.bytesAvailable);
var responseList:Array = response.split("\n");
// Apparently we always get a linebreak with a response...
responseList.pop();
var eventList:Array = new Array();
var evt:FTPEvent;
for(var i:int = 0; i < responseList.length; i++) {
evt = new FTPEvent(FTPEvent.RESPONSE);
evt.response = FTPResponse.parseResponse(responseList[i]);
eventList.push(evt);
if (FTPClient.DEBUG) trace("->" + evt.response.code+" "+evt.response.message);
}
if(swallowNextResponse) {
if (FTPClient.DEBUG) trace(" - ignoring this response...");
swallowNextResponse = false;
responseList.shift();
}
if(responseList.length > 0) {
for(var k:int = 0; k < responseList.length; k++) {
dispatchEvent(eventList[k]);
}
}
}

Links

Flex + Java = Frankenstein?

Posted on February 8, 2011 by Wijnand

Lately I’ve been working on a small upload tool in Flex/AIR.
To verify that an upload has succeeded, I created a hash (md5) of the entire file and sent that to the backend for verification. The AS3CoreLib contains a nice MD5 class, MD5Stream, but it’s much too slow for creating a checksum of files.

Actually, it’s so slow that when I was uploading a 5+ MB file the application would slow down so much that the upload speed dropped to a third of the speed without feeding the MD5Stream data during uploading.
Luckily, with AIR 2.0 NativeProcess has been introduced, it made it much easier to “outsource” complicated calculation to a process that can deal with that much better, i.e. Java.

The nice thing about Java is that it’s cross-platform just as AIR, and these days many people will have the JRE installed.Â So first of all, I wrote a small Java class that would print out an MD5 hash of a file based on the path that I passed. I jarred the class and added it to my AIR project.
The second step was to call my Java class instead of the AS3 MD5Stream class. This is surprisingly easy. The NativeProcess documentation comes with a pretty clear example and Piotr Walczyszyn has created a small framework, Flerry, to let Flex talk to Java and vice versa.

Looking at how Flerry is built will give you some more insight on how to deal with NativeProcess.
For my application, I only use the BaseStartupInfoProvider class from Flerry to find where Java is installed on the user’s machine. After that I set up all event listeners as per the NativeProcess documentation and call NativeProcess.start() with a NativeProcessStartupInfo as passed in parameter.
Now my uploads are fast again and I can generate a checksum in a fraction of the time I could before.

There are unfortunately some downsides to this approach. You have to deploy your AIR application as native installer to be able to use the NativeProcess class. So instead of having one AIR file, you’ll end up with four native installers (.exe, .dmg, .deb, .rpm). On the plus side, you can create the native installers from an AIR file without needing to resign the application.
Another downside is that now I’m relying on two runtimes being installed on the end user’s machine, AIR and Java.
My final thought is that now that I am outsourcing some calculations to Java, why not built the whole thing in Java? Then again, building a decent UI can take ages using Java. To me, my application feels like I’m creating a bit of a Frankenstein.

All in all I’m glad I now have a fast way to generate a checksum and my uploads aren’t slowed down by it any more.

Links:

Flex FTP EPSV support

Posted on February 7, 2011 by Wijnand

Still working with Flex FTP and this time I was missing EPSV support. EPSV is roughly the same as PASV, exect that you only get a port number to connect to back and not an IP address. You can read up on RFC 2428 “FTP Extensions for IPv6 and NATs” if you want more details.

The first thing I did to add support for EPSV in Flex FTP is adding a response to the Responses class.

public static const ENTERING_EPSV:int = 229; //Entering Extended Passive Mode.

Second was the commands class, where I added the following line:

public static const EPSV:String = "EPSV";

Then I added an extra argument to the FTPClient class’ constructor that will indicate whether or not to use ESPV.

public function FTPClient (host:String="", port:int=21, useEpsv:Boolean = false)

I store the value internally and use a getter method to determine if an Invoker class (i.e ListInv) needs to use EPSV.

Based on the client epsv setting any invoker can be updated to send the EPSV command instead of the PASV command when needed, i.e. my implementation of ListInv’s startSequence method:

override protected function startSequence ():void {
if(client.useEpsv) {
sendCommand(new FTPCommand(Commands.EPSV));
} else {
sendCommand(new FTPCommand(Commands.PASV));
}
}

I also update the responseHandler method in ListInv to include the following case:

case Responses.ENTERING_EPSV:
passiveSocket =Â Â Â PassiveSocketInfo.createPassiveSocket(evt.response.message,
handlePassiveConnect,
handleListing, ioErrorHandler,
null, true, client.hostname);
break;

On top of that I made some tweaks to the PassiveSocketInfo class.
The parseFromResponse method now looks like this:

public static function parseFromResponse (pasvResponse:String, usingEpsv:Boolean = false, hostName:String = ""):PassiveSocketInfo {
var host:String;
var port:int;
if (usingEpsv) {
host = hostName;
port = pasvResponse.match(/\d+/)[0];
} else {
var match:Array = pasvResponse.match(/(\d{1,3},){5}\d{1,3}/);
if (match == null)
throw new Error("Error parsing passive port! (Response: "+pasvResponse+")");
var data:Array = match[0].split(",");
host = data.slice(0,4).join(".");
port = parseInt(data[4])*256+parseInt(data[5]);
}
return new PassiveSocketInfo(host, port);
}

The createPassiveSocket method now takes two extra optional arguments (usingEpsv:Boolean and host:String) and just passes those on to the parseFromResponse method.

Hope this helps anybody looking for EPSV support for Flex FTP.

PS: It’s been a while since I added EPSV support, so let me know about any gaps.

W.J. Warren

Android Developer

Monthly Archives: February 2011

Flex FTP Abort

Flex + Java = Frankenstein?

Flex FTP EPSV support