FCSH Wrapper

Welcome

2008-04-22T22:30:00.004+03:00

This is a wrapper over the fcsh (Flex Compiler Shell) that expose the fcsh.exe to be accessed from an ant task. You can send mxmlc commands from ant tasks to a wrapped fcsh instance.
You can post comments on the blog's topics.

Some detailes about code

2008-04-22T22:24:00.055+03:00

Sources are available to download as an archive on sourceforge (fcshWrapper-src.0.1.2.tgz). Or can be checked out from CSV.

Unfortunately I made the wrapper to run only on Windows because is all that I need. But it can be easily modified to run on other platforms (Windows specific is jdic from dev.java.net that makes the app available in system tray and some hardcoded calls to fcsh.exe).

If the LoggingFrame is made abstract and an implementation redirect the fcsh output to a file and then the TaskbarStatusArea is removed or is made to be a generic notification system on errors, the wrapper can be made available to an OS without a graphical user interface.

As I see now, in java 6, there is a built in support for system tray, but i don't see any jvm 6 for Mac. And jdic has support only for Windows/Linux/Solaris. So, sorry for Mac users (maybe a version without sys tray).

Classes:

AntTaskGateway.java
CommandArg.java
CommandsHistory.java
FcshCommandHandler.java
FcshCommandListener.java
FcshProcessWrapper.java
FcshTask.java
LoggingFrame.java
Main.java
TaskbarStatusArea.java
WrapperCreator.java

This is the story:

ANT calls FcshTask's execute() method that instantiate an AntTaskGateway ant call his send(command, args) function.

AntTaskGateway first tries to create a socket connection on localhost (initConnection() method that calls connect()), then it simply serialize to the socket the command and his arguments and wait for the response from fcsh.exe.

If initConnection() fails, the build fails. If the first call to the connect() fails, initConnection() creates a WrapperCreator ant calls the method startAndWaitForInit().

WrapperCreator.startAndWaitForInit() start the ro.arhinet.fcshwrapper.wrapper.Main (that is a main class) in a separate process. Then capture the subprocess output and wait for a signal that all is initialized OK. If something goes wrong the build fail.

That's almost all for the first part. The ANT process exits, but the lunched subprocess stays up and listen for upcoming compile commands.

The main class of the wcshWrapper process is ro.arhinet.fcshwrapper.wrapper.Main that luches 4 services:

public class Main{
    public static void main(String args[]) throws Exception {
        LoggingFrame.initUI();
        TaskbarStatusArea.initSysTray();
        FcshProcessWrapper.startFcshProcess();
        FcshCommandListener.startServer();
        System.out.println("[FCSH initalized]");
    }
}

A little to many singletons in a package wint 5 classes. But i look at these classes as services and services must be available anywhere via static calls.

LoggingFrame maintains history with issued command, the output from the fcsh and any other errors/messages. The service can be accessed via:

    public void logMessage(String content, String color)
    public void logMessage(String content)
    public void logError(String content)
    public void logFcshCommand(String content)
    public void logWarning(String content)
    public void logSystemError(String content, Throwable error)
    public void clearLog()

TaskbarStatusArea controls the visibility of the LoggingFrame and displays notification balloons. Services exposed:

    public static void reportErrorInSysTray(String title, String error)
    public static void reportErrorInSysTray(String title, Throwable error)
    public static void reportErrorInSysTray(Throwable error)

FcshProcessWrapper start the fcsh.exe subprocess on the time of his static initialization. It knows how to handle the subprocess output that redirects it to LoggingFrame and how to execute a command on the fcsh.exe.

FcshCommandListener listen for incoming connections and for each request create an instance of FcshCommandHandler that manage the communication with the client.

FcshCommandHandler works with other service: CommandsHistory that maintains a HashMap of issued fcsh commands using the md5 of the command (+args.) for hash keys. Each entry in the HashMap contains the id allocated by the fcsh.exe for that command.

How to use fcshWrapper

2008-04-21T14:18:00.022+03:00

Download the binaries [FCSH Wrapper 0.1.2], unpack to any directory you want. Specify FCSHWRAPP_HOME property to point to the directory where you unpacked the binaries, FLEX_HOME to your flex sdk directory. FCSHWRAPP_JRE and FCSHWRAPP_PORT are not mandatory.

FCSHWRAPP_JRE must point to a jre 1.5 or higher, but if it is not specify, the jre used to lunch the wrapper will be searched in JAVA_HOME then JRE_HOME. If none of these are specified, it relays on the system PATH to lunch the wrapper. The default port on which the wrapper accepts commands is 52795. If you wont another port you can specify it on the FCSHWRAPP_PORT property.

A sample build file using fcshWrapper:

testScript.xml

<?xml version="1.0" encoding="UTF-8"?>
<project name="changeme" default="all" basedir=".">
   <property name="FCSHWRAPP_PORT" value="52797"/>
   <property name="FCSHWRAPP_JRE" value="C:/Program Files/Java/jdk1.5.0_11"/>
   <property name="FCSHWRAPP_HOME" value="d:/fcshWrapper-bin/bin"/>
   <property name="FLEX_HOME" value="c:/flex-sdk"/>
  
   <path id="mypath">
       <fileset dir="${FCSHWRAPP_HOME}" includes="fcshWrapper.jar"/>
   </path>
  
   <taskdef name="fcsh" classname="ro.arhinet.fcshwrapper.ant.FcshTask">
       <classpath refid="mypath"/>
   </taskdef>
  
   <target name="all">
       <fcsh command="mxmlc">
           <arg value="c:\ArhiNET.project\arhinet\web\flex-pages\app1.mxml"/>
           <arg value=" "/>
       </fcsh>
   </target>
</project>

Unfortunately I have build the application to work only on windows, but with some minor changes (another jdic binaries and removing '.exe' hardcoded calls in code) can be made to run on any other platform.

The first time the ant task is called, it observes that nobody is listening on the specified port and auto-lunches the wrapper as a separate process that can be observed on the system tray.

The output of the fcsh.exe is redirected to the ant task. The ant task fails if there is an error compiling flex files. The fcshWrapper remember the commands received and their assigned ids by the fcsh.

The wrapper stays on the system tray and notifies you when the build fails.

And there is also a console with all the commands received by the wrapper that can be hided/displayed from the system tray.

Publishing FCSH Wrapper on sourceforge.net

2008-04-21T00:28:00.010+03:00

I have published sources and jars on sourceforge at http://sourceforge.net/projects/fcshwrapper

A few words about this project:

Few months ago I decided to use flex as my presentation tier for my new project. The first think I make it was to use Flex Ant Tasks from Adobe Labs, but soon I found that it takes too long to compile a simple mxml file.
I founded on Adobe Labs a project named Flex Compiler Shell (FCSH), that now is included in flex sdk.

So, here comes the bad news ... FCSH is very, very poor designed so it cannot be used into an automated build script.
The only project that I found on the net that seems to resolve that problem is iFac (http://ifac-plugin.com/). Again bad news:
- iFac is intended to be used only as a Eclipse plug-in,
- the binaries are available only from eclipse "Software Updates -> Find and install",
-,and worse, I believe that sources are not available since they adopt a license that forbid you to modify their sources.

So I decided to write my on wrapper over the fcsh.exe.
The sources and binaries are available at sourceforge: http://sourceforge.net/projects/fcshwrapper/ And you are free to adapt the sources to your needs.