flex-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From dlove...@apache.org
Subject [1/4] git commit: [flex-utilities] [refs/heads/develop] - FLEX-34809 Flex Code Coverage Tool
Date Sun, 22 Mar 2015 01:19:51 GMT
Repository: flex-utilities
Updated Branches:
  refs/heads/develop 495edeb1f -> e83f27a0a


http://git-wip-us.apache.org/repos/asf/flex-utilities/blob/5077c457/CodeCoverage/JavaServer/java/src/org/apache/flex/tools/codecoverage/reporter/swf/SWFLineReporter.java
----------------------------------------------------------------------
diff --git a/CodeCoverage/JavaServer/java/src/org/apache/flex/tools/codecoverage/reporter/swf/SWFLineReporter.java
b/CodeCoverage/JavaServer/java/src/org/apache/flex/tools/codecoverage/reporter/swf/SWFLineReporter.java
new file mode 100755
index 0000000..500917e
--- /dev/null
+++ b/CodeCoverage/JavaServer/java/src/org/apache/flex/tools/codecoverage/reporter/swf/SWFLineReporter.java
@@ -0,0 +1,143 @@
+/*
+ *
+ *  Licensed to the Apache Software Foundation (ASF) under one or more
+ *  contributor license agreements.  See the NOTICE file distributed with
+ *  this work for additional information regarding copyright ownership.
+ *  The ASF licenses this file to You under the Apache License, Version 2.0
+ *  (the "License"); you may not use this file except in compliance with
+ *  the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ *
+ */
+
+package org.apache.flex.tools.codecoverage.reporter.swf;
+
+import java.io.BufferedInputStream;
+import java.io.FileNotFoundException;
+import java.io.IOException;
+import java.net.URL;
+import java.util.Collection;
+
+import org.apache.commons.io.IOUtils;
+import org.apache.flex.abc.ABCParser;
+import org.apache.flex.compiler.clients.problems.CompilerProblemCategorizer;
+import org.apache.flex.compiler.clients.problems.ProblemFormatter;
+import org.apache.flex.compiler.clients.problems.ProblemPrinter;
+import org.apache.flex.compiler.clients.problems.ProblemQuery;
+import org.apache.flex.compiler.clients.problems.WorkspaceProblemFormatter;
+import org.apache.flex.compiler.internal.workspaces.Workspace;
+import org.apache.flex.compiler.problems.ICompilerProblem;
+import org.apache.flex.swf.TagType;
+import org.apache.flex.swf.io.SWFReader;
+import org.apache.flex.swf.tags.DoABCTag;
+import org.apache.flex.swf.tags.ITag;
+import org.apache.flex.tools.codecoverage.reporter.CoverageData;
+
+import com.google.common.collect.ImmutableList;
+
+/**
+ * Read in a SWF file and report the debugs line with the methods names. 
+ *
+ * The data is returned in a Map where the key is the "path;package;file" string.
+ * The value is another Map where the key is the line number of the line. The
+ * value is a LineInfo object.
+ */
+public class SWFLineReporter
+{
+
+    private final String path;
+    
+    /**
+     * Constructor.
+     * 
+     * @param path The path of the SWF to read.
+     */
+    public SWFLineReporter(final String path)
+    {
+        this.path = path;
+    }
+    
+    /**
+     * Read the debug lines from the SWF and populate the coverage data.
+     * 
+     * @param coverageData The coverage data to add the debug lines to.
+     * @throws IOException
+     */
+    public void readLines(final CoverageData coverageData) 
+            throws IOException
+    {
+        final SWFReader swfReader = new SWFReader(false);
+        final URL url = new URL(path);
+        
+        try
+        {
+            swfReader.readFrom(
+                    new BufferedInputStream(url.openStream()),
+                    path);
+
+            ProblemQuery problemQuery = new ProblemQuery();
+            problemQuery.addAll(swfReader.getProblems());
+            if (!problemQuery.hasErrors())
+            {
+                final ImmutableList<ITag> tags = ImmutableList.copyOf(swfReader.iterator());
+                for (ITag tag : tags)
+                {
+                    // visit the DoABC tag
+                    if (tag.getTagType() == TagType.DoABC)
+                    {
+                        processDoABC((DoABCTag)tag, coverageData);
+                    }
+                }
+            }
+
+            printProblems(swfReader.getProblems());
+        }
+        catch (FileNotFoundException e)
+        {
+        	System.err.println("Error: Unable read debug lines from " + e.getLocalizedMessage());
+        	throw e;
+        }
+        finally
+        {
+            IOUtils.closeQuietly(swfReader);
+        }
+    }
+    
+    /**
+     * Parse a DoABC record and add the debug lines to the coverage data.
+     * 
+     * @param tag The ABC tag.
+     * @param coverageData The coverage data to populate.
+     */
+    private void processDoABC(final DoABCTag tag, final CoverageData coverageData)
+    {
+        // create a visitor to record source line numbers.
+        final ABCParser parser = new ABCParser(tag.getABCData());
+        final DebugLineVisitor debugLineVisitor = new DebugLineVisitor(coverageData);
+        parser.parseABC(debugLineVisitor);
+    }
+
+    /**
+     * Print out problems to standard output.
+     * 
+     * @param problems
+     */
+    private void printProblems(final Collection<ICompilerProblem> problems)
+    {
+        final CompilerProblemCategorizer categorizer = new CompilerProblemCategorizer();
+        final ProblemFormatter formatter = new WorkspaceProblemFormatter(new Workspace(),
+                categorizer);
+        final ProblemPrinter printer = new ProblemPrinter(formatter, System.err);
+
+        printer.printProblems(problems);
+    }
+
+    
+}

http://git-wip-us.apache.org/repos/asf/flex-utilities/blob/5077c457/CodeCoverage/JavaServer/java/src/org/apache/flex/tools/codecoverage/server/CodeCoverageServer.java
----------------------------------------------------------------------
diff --git a/CodeCoverage/JavaServer/java/src/org/apache/flex/tools/codecoverage/server/CodeCoverageServer.java
b/CodeCoverage/JavaServer/java/src/org/apache/flex/tools/codecoverage/server/CodeCoverageServer.java
new file mode 100755
index 0000000..73b4b06
--- /dev/null
+++ b/CodeCoverage/JavaServer/java/src/org/apache/flex/tools/codecoverage/server/CodeCoverageServer.java
@@ -0,0 +1,552 @@
+/*
+ *
+ *  Licensed to the Apache Software Foundation (ASF) under one or more
+ *  contributor license agreements.  See the NOTICE file distributed with
+ *  this work for additional information regarding copyright ownership.
+ *  The ASF licenses this file to You under the Apache License, Version 2.0
+ *  (the "License"); you may not use this file except in compliance with
+ *  the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ *
+ */
+
+package org.apache.flex.tools.codecoverage.server;
+
+import java.io.BufferedReader;
+import java.io.BufferedWriter;
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.io.FileReader;
+import java.io.FileWriter;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+import java.io.Reader;
+import java.io.UnsupportedEncodingException;
+import java.net.ConnectException;
+import java.net.ServerSocket;
+import java.net.Socket;
+import java.net.URL;
+import java.net.URLDecoder;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Properties;
+
+/**
+ * Main class of the Code Coverage Server.
+ * 
+ * This class serves the command port.
+ * Creates threads to serve the data port and the policy file port.
+ *
+ */
+public class CodeCoverageServer
+{
+    private static enum ExitCode
+    {
+        SUCCESS(0),
+        HELP(1),
+        INVALID_OPTIONS(2),
+        ERRORS(3);
+        
+        private final int exitCode;
+        
+        private ExitCode(int exitCode)
+        {
+            this.exitCode = exitCode;
+        }
+        
+        public int getExitCode()
+        {
+            return exitCode;
+        }
+    }
+    
+    /**
+     * Commands
+     */
+    public static final String START_COMMAND = "start";
+    public static final String STOP_COMMAND = "stop";
+    public static final String STATUS_COMMAND = "status";
+    public static final String ALIVE_COMMAND = "alive";
+    
+    /**
+     * Responses
+     */
+    public static final String SUCCESS_RESPONSE = "0";
+    public static final String ERROR_RESPONSE = "-1";
+    
+    /**
+     * Default configuration values
+     */
+    private static final String DEFAULT_HOST = "localhost";
+    private static final int DEFAULT_DATA_PORT = 9097;
+    private static final int DEFAULT_COMMAND_PORT = 9098;
+    private static final int DEFAULT_POLICY_FILE_PORT = 9843;
+    private static final String DEFAULT_PRELOAD_SWF = "CodeCoveragePreloadSWF.swf"; 
+    
+    /**
+     * config.properties keys
+     */
+    private static final String MM_CFG_PATH = "mmCfgPath";
+    private static final String PRELOAD_SWF_KEY = "preloadSWF";
+    private static final String DATA_DIRECTORY_KEY = "dataDirectory";
+    private static final String HOST_KEY = "host";
+    private static final String DATA_PORT_KEY = "dataPort";
+    private static final String COMMAND_PORT_KEY = "commandPort";
+    private static final String POLICY_FILE_PORT_KEY = "policyFilePort";
+    
+    private static final boolean ADD_PRELOADSWF_KEY = true;
+    private static final boolean REMOVE_PRELOADSWF_KEY = false;
+
+    private static final String CCSERVER_VERSION = "0.9";
+    
+    private static boolean start;
+    private static boolean stop;
+   
+    /**
+     * @param args
+     */
+    public static void main(String[] args) 
+    {
+        CodeCoverageServer server = new CodeCoverageServer();
+        final int exitCode = server.mainNoExit(args);
+        System.exit(exitCode);
+    }
+
+    /**
+     * Entry point for the server instance.
+     * 
+     * @param args Command line args
+     * @return One of EXIT_CODE enum.
+     */
+    private int mainNoExit(String[] args)
+    {
+        System.out.println("Apache Flex Code Coverage Server");
+        System.out.println("Version " + CCSERVER_VERSION);
+        System.out.println("");
+
+        if (args.length == 0 ||
+            args.length == 1 && "-help".equals(args[0]))
+        {
+            System.out.println("Usage: ccserver [start | stop]");
+            return ExitCode.HELP.getExitCode();
+        }
+
+        try
+        {
+            if (!initializeProperties())
+                return ExitCode.INVALID_OPTIONS.getExitCode();
+
+            processArgs(args);
+            if (start)
+                start();
+            else if (stop)
+                stop();
+        }
+        catch (IOException e)
+        {
+            e.printStackTrace();
+            return ExitCode.ERRORS.getExitCode();
+        }
+        catch (InterruptedException e)
+        {
+            e.printStackTrace();
+            return ExitCode.ERRORS.getExitCode();
+        }
+
+        return ExitCode.SUCCESS.getExitCode();
+    }
+
+    private Properties config = new Properties();
+    private boolean listening = true;
+    private String host;
+    private int dataPort;
+    private int commandPort;
+    private int policyFilePort;
+    private String preloadSWFPath;
+    
+    /**
+     * Constructor.
+     */
+    public CodeCoverageServer() 
+    {
+    }
+    
+    private void processArgs(final String[] args)
+    {
+        for (final String arg : args)
+        {
+            switch (arg)
+            {
+                case START_COMMAND:
+                {
+                    start = true;
+                    break;
+                }
+                case STOP_COMMAND:
+                {
+                    stop = true;
+                    break;
+                }
+                default:
+                {
+                    System.err.println("unexpected argument " + arg);
+                }
+            }
+        }
+    }
+
+    /**
+     * Starts the server.
+     * 
+     * @throws IOException
+     * @throws InterruptedException
+     */
+    public void start() throws IOException, InterruptedException
+    {
+        if (isAlive())
+        {
+            System.out.println("Apache Flex Code Coverage Server is already running");
+            return;
+        }
+        
+        final String dataProperty = config.getProperty(DATA_DIRECTORY_KEY, 
+                System.getProperty("user.home"));
+        final File dataDirectory = new File(dataProperty, "ccdata");
+        
+        if (!dataDirectory.exists())
+        {
+            // mkdir() is creating the directory but returning false, so
+            // re-test with exists()
+            if (!dataDirectory.mkdir() && !dataDirectory.exists())
+            {
+                System.err.println("Error: Data directory does not exist and unable to create
it: " + dataDirectory.getAbsolutePath());
+                return;
+            }
+        }
+        
+        // modify mm.cfg file
+        updateMMCFG(ADD_PRELOADSWF_KEY);
+
+        // create thread to listen for connections on the data port
+        final DataSocketAccepter dataSocketAccepter = 
+                new DataSocketAccepter(host, dataPort, dataDirectory);
+        final Thread dataThread = new Thread(dataSocketAccepter);
+        dataThread.start();
+        
+        // create thread to listen the policy file port and server up the socket policy file.
+        final PolicyFileServer policyFileServer = new PolicyFileServer(host,
+                dataPort, policyFilePort);
+        final Thread policyFileServerThread = new Thread(policyFileServer);
+        policyFileServerThread.start();
+        
+        System.out.println("listening on port " + dataPort);
+
+        // read commands on command socket
+        final ServerSocket commandSocket = new ServerSocket(commandPort);
+        
+        try
+        {
+            while (listening)
+            {
+                try (Socket socket = commandSocket.accept();
+                     InputStreamReader reader = new InputStreamReader(socket.getInputStream());
+                     OutputStreamWriter writer = new OutputStreamWriter(socket.getOutputStream()))
+                {
+                    // wait for request
+                    char[] cbuf = new char[256];
+                    int charsRead = reader.read(cbuf);
+                    if (charsRead > 0)
+                    {
+                        processCommand(reader, writer, String.valueOf(cbuf).trim());
+                    }
+                }
+            }
+        }
+        finally
+        {
+            commandSocket.close();
+            policyFileServer.close();
+            policyFileServerThread.join();
+            dataSocketAccepter.close();
+            dataThread.join();
+            updateMMCFG(REMOVE_PRELOADSWF_KEY);        	
+        }
+        
+        System.out.println("stopping Apache Flex Code Coverage Server");
+    }
+
+    /**
+     * Process a server command.
+     * 
+     * @param reader The socket reader.
+     * @param writer The socket writer.
+     * @param command The command to process.
+     * @throws IOException 
+     */
+    private void processCommand(final InputStreamReader reader, 
+            final OutputStreamWriter writer, final String command) throws IOException
+    {
+        String response = SUCCESS_RESPONSE;
+        
+        switch (command)
+        {
+            case STOP_COMMAND:
+            {
+                listening = false;
+                break;
+            }
+            case ALIVE_COMMAND:
+            {
+                break;
+            }
+            default:
+            {
+                response = ERROR_RESPONSE;
+                System.err.println("ccserver: unknown command " + command);
+            }
+        }
+        
+        // acknowledge command
+        writer.append(response);
+        writer.flush();
+    }
+
+    /**
+     * Initialize properties from config file.
+     * Validate the properties.
+     * 
+     * @return true if the properties are valid, false otherwise.
+     * @throws IOException
+     */
+    private boolean initializeProperties() throws IOException
+    {
+        readProperties();
+        
+        host = config.getProperty(HOST_KEY, DEFAULT_HOST);
+        dataPort = getIntegerProperty(DATA_PORT_KEY, DEFAULT_DATA_PORT);
+        commandPort = getIntegerProperty(COMMAND_PORT_KEY, DEFAULT_COMMAND_PORT);
+        policyFilePort = getIntegerProperty(POLICY_FILE_PORT_KEY, DEFAULT_POLICY_FILE_PORT);
+
+        // get absolute path of preloadSWF.
+        if (!initializePreloadSWF())
+            return false;
+        
+        return true;
+    }
+
+    /**
+     * Initialize the preloadSWF value.
+     * 
+     * @return true if value, false otherwise.
+     * @throws UnsupportedEncodingException 
+     */
+    private boolean initializePreloadSWF() throws UnsupportedEncodingException
+    {
+        // if the path of the preload SWF is not configured, then try to locate
+        // it in the same directory as the jar containing this class.
+        preloadSWFPath = config.getProperty(PRELOAD_SWF_KEY, DEFAULT_PRELOAD_SWF);
+        File preloadSWFFile = new File(preloadSWFPath);
+        if (!preloadSWFFile.exists())
+        {
+            URL preloadSWFURL = getClass().getClassLoader().getResource(preloadSWFPath);
+            if (preloadSWFURL != null)
+            {
+                preloadSWFPath = URLDecoder.decode(preloadSWFURL.getPath(), "UTF-8");
+                preloadSWFFile = new File(preloadSWFPath);
+            }
+            
+            if (!preloadSWFFile.exists())
+            {
+                System.out.println("preloadSWF not found: " + preloadSWFPath);
+                return false;
+            }
+        }
+        
+        preloadSWFPath = preloadSWFFile.getAbsolutePath();
+        return true;
+    }
+
+    /**
+     * Handle NumberFormatExeptions values in the configuration file.
+     * 
+     * @param key
+     * @param defaultValue
+     * @return integer value of a configuration value.
+     */
+    private int getIntegerProperty(String key, int defaultValue)
+    {
+        String value = config.getProperty(key);
+        int result = defaultValue;
+        
+        try
+        {
+            result = Integer.valueOf(value);            
+        }
+        catch (NumberFormatException e)
+        {
+            // ignore, result is already set to defualt value
+        }
+        
+        return result;
+    }
+    
+    /**
+     * Send command to the command port to stop the server.
+     * 
+     * @throws IOException
+     */
+    public void stop() throws IOException
+    {
+        if (!isAlive())
+        {
+            System.out.println("Apache Flex Code Coverage Server not running");
+            return;
+        }
+
+        // connect to the server and send a command
+        sendCommand(STOP_COMMAND);
+    }
+    
+    /**
+     * Read properties from the config.properties file.
+     * 
+     * @throws IOException
+     */
+    private void readProperties() throws IOException
+    {
+        try (InputStream inputStream = getClass().getClassLoader().
+                getResourceAsStream("ccserver.properties"))
+        {
+            if (inputStream != null)
+                config.load(inputStream);
+        }
+    }
+    
+    /**
+     * Update the user's mm.cfg file to either add or remove the preloadSWF
+     * key.
+     * 
+     * @param addPreloadSWF If true add "preloadSWF=" to the user's mm.cfg.
+     * @throws IOException 
+     */
+    private void updateMMCFG(final boolean addPreloadSWF) throws IOException
+    {
+        // open mm.cfg
+        String filename = config.getProperty(MM_CFG_PATH, 
+                System.getProperty("user.home") + "/mm.cfg");
+        
+        // read mm.cfg
+    	List<String> lines = new ArrayList<String>();
+        try (Reader fileReader = new FileReader(filename);
+        	 BufferedReader bufferedReader = new BufferedReader(fileReader))
+        {
+        	String line = null;
+        	while ((line = bufferedReader.readLine()) != null)
+        	{
+    			// if found a preloadSWF line then don't write it in order to 
+    			// remove it. If we are adding the line we will append it later.
+        		if (!(line.startsWith(PRELOAD_SWF_KEY + "=")))
+        		{
+        			lines.add(line);
+        		}
+        	}
+            
+        	// if adding the preloadSWF key, append the preloadSWF property
+        	if (addPreloadSWF)
+        	{
+        	    StringBuilder preloadSWF = new StringBuilder(PRELOAD_SWF_KEY);
+        	    preloadSWF.append("="); 
+        	    preloadSWF.append(preloadSWFPath);
+        	    preloadSWF.append("?host=");
+        	    preloadSWF.append(host);
+        	    preloadSWF.append("&dataPort=");
+        	    preloadSWF.append(dataPort);
+        	    preloadSWF.append("&policyFilePort=");
+        	    preloadSWF.append(policyFilePort);
+        		lines.add(preloadSWF.toString());
+        	}
+        }
+        catch (FileNotFoundException e)
+        {
+            System.err.println("Unable to open mm.cfg. Create the file in the user home directory
or specify the location by setting the mmCfgPath property in ccserver.properties.");
+            e.printStackTrace();
+            return;
+        }
+        
+        // write mm.cfg
+        try (FileWriter fileWriter = new FileWriter(filename);
+        	 BufferedWriter bufferedWriter = new BufferedWriter(fileWriter))
+        {
+        	for (String line : lines)
+        	{
+        		bufferedWriter.write(line);
+        		bufferedWriter.newLine();
+        	}
+        }
+        
+    }
+    
+    /**
+     * Send a command and get the response.
+     * 
+     * @param command
+     * @return A String containing the response. If there is no response an
+     * empty string will be returned. 
+     * @throws IOException
+     */
+    private String sendCommand(String command) throws IOException
+    {
+        String result = "";
+        char[] cbuf = new char[512];
+
+        try (Socket socket = new Socket(host, commandPort);
+            InputStreamReader reader = new InputStreamReader(socket.getInputStream());
+            PrintWriter writer = new PrintWriter(socket.getOutputStream()))
+        {
+            // send command
+            writer.print(command);
+            writer.flush();
+
+            // read response
+            int charsRead = reader.read(cbuf);
+            if (charsRead != -1)
+                result = String.valueOf(cbuf, 0, charsRead);
+        }
+        
+        return result;
+    }
+    
+    /**
+     * Test if the server is already running.
+     * 
+     * @return true if the server is running, false otherwise.
+     * @throws IOException 
+     */
+    private boolean isAlive() throws IOException
+    {
+        try 
+        {
+            String result = sendCommand(ALIVE_COMMAND);
+            if (result.length() > 0)
+                return true;
+            
+            return false;
+        }
+        catch (ConnectException e)
+        {
+            // server not running so connection failed.
+            return false;
+        }
+    }
+    
+}

http://git-wip-us.apache.org/repos/asf/flex-utilities/blob/5077c457/CodeCoverage/JavaServer/java/src/org/apache/flex/tools/codecoverage/server/DataSocketAccepter.java
----------------------------------------------------------------------
diff --git a/CodeCoverage/JavaServer/java/src/org/apache/flex/tools/codecoverage/server/DataSocketAccepter.java
b/CodeCoverage/JavaServer/java/src/org/apache/flex/tools/codecoverage/server/DataSocketAccepter.java
new file mode 100755
index 0000000..1de9992
--- /dev/null
+++ b/CodeCoverage/JavaServer/java/src/org/apache/flex/tools/codecoverage/server/DataSocketAccepter.java
@@ -0,0 +1,174 @@
+/*
+ *
+ *  Licensed to the Apache Software Foundation (ASF) under one or more
+ *  contributor license agreements.  See the NOTICE file distributed with
+ *  this work for additional information regarding copyright ownership.
+ *  The ASF licenses this file to You under the Apache License, Version 2.0
+ *  (the "License"); you may not use this file except in compliance with
+ *  the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ *
+ */
+
+package org.apache.flex.tools.codecoverage.server;
+
+import java.io.BufferedWriter;
+import java.io.File;
+import java.io.FileWriter;
+import java.io.IOException;
+import java.net.ServerSocket;
+import java.net.Socket;
+
+/**
+ * Thread to accept requests to connections to the data port.
+ * When a connection is made an instance of the DataSocketThread is created to
+ * read data from the socket.
+ * 
+ */
+public class DataSocketAccepter implements Runnable
+{
+
+    private static final String filenameTemplate = "ccdata_{0}.txt";
+
+    private ServerSocket socket;
+    private BufferedWriter fileWriter;
+    private Thread dataSocketReader;
+    private volatile boolean listening = true;
+    private final File dataDirectory;
+    private int fileCount = 0;
+    private Socket currentSocket;
+    private final String host;
+    private final int dataPort;
+    
+    /**
+     * Constructor.
+     * 
+     * @param host The host of the dataPort.
+     * @param dataPort The data port to service.
+     * @param dataDirectory The directory where the data files are stored.
+     * Each new connection results in a new file created in this directory.
+     */
+    public DataSocketAccepter(final String host, final int dataPort, 
+            final File dataDirectory)
+    {
+       
+       if (dataDirectory == null)
+           throw new NullPointerException("dataDirectory may not be null");
+        
+       this.host = host;
+       this.dataPort = dataPort;
+       this.dataDirectory = dataDirectory;
+    }
+    
+    /**
+     * This thread will block waiting on a connect to the data port. Once a 
+     * connection has been made an instance of DataSocketThread is run to read
+     * the data on the port and this thread waits for the next connection.
+     * Only one instance of the DataSocketThread is allowed. Before a new instance
+     * is created the current one is closed.
+     */
+    @Override
+    public void run() 
+    {
+        try
+        { 
+            socket = new ServerSocket(dataPort);
+            
+            while (listening) 
+            {
+                Socket newSocket = socket.accept();
+                
+                closeResources();
+                currentSocket = newSocket;
+                
+                if (!listening)
+                    break;
+                
+                String filename = filenameTemplate.replace("{0}", String.valueOf(fileCount++));
+                File file = new File(dataDirectory, filename);
+                System.out.println("saving trace data to " + file.getAbsolutePath());
+                fileWriter = new BufferedWriter(new FileWriter(file));
+                dataSocketReader = new Thread(new DataSocketReader(newSocket, fileWriter));
+                dataSocketReader.start();
+            }
+        } 
+        catch (IOException e) 
+        {
+            e.printStackTrace();
+        } catch (InterruptedException e)
+        {
+            e.printStackTrace();
+        }
+        finally
+        {
+            if (currentSocket != null)
+            {
+                try 
+                {
+                    currentSocket.close();
+                }
+                catch (IOException e1)
+                {
+                    e1.printStackTrace();
+                }
+            }
+            
+            if (fileWriter != null)
+            {
+                try 
+                {
+                    fileWriter.close();
+                } 
+                catch (IOException e)
+                {
+                    e.printStackTrace();
+                }
+            }            
+        }
+    }
+
+    /**
+     * Close this thread.
+     * 
+     * @throws IOException 
+     * @throws InterruptedException 
+     */
+    public void close() throws IOException
+    {
+        // connect to socket to unblock the accept call
+        listening = false;
+        Socket socket = new Socket(host, dataPort);
+        socket.close();
+    }
+    
+    /**
+     * Close the resources used by data socket thread.
+     * @throws InterruptedException
+     * @throws IOException
+     */
+    private void closeResources() throws InterruptedException, IOException
+    {
+        if (dataSocketReader != null)
+        {
+            dataSocketReader.interrupt();
+            dataSocketReader.join();
+            dataSocketReader = null;
+        }
+        
+        if (currentSocket != null)
+            currentSocket.close();
+        
+        if (fileWriter != null)
+        {
+            fileWriter.close();
+            fileWriter = null;
+        }
+    }
+}

http://git-wip-us.apache.org/repos/asf/flex-utilities/blob/5077c457/CodeCoverage/JavaServer/java/src/org/apache/flex/tools/codecoverage/server/DataSocketReader.java
----------------------------------------------------------------------
diff --git a/CodeCoverage/JavaServer/java/src/org/apache/flex/tools/codecoverage/server/DataSocketReader.java
b/CodeCoverage/JavaServer/java/src/org/apache/flex/tools/codecoverage/server/DataSocketReader.java
new file mode 100755
index 0000000..6a15168
--- /dev/null
+++ b/CodeCoverage/JavaServer/java/src/org/apache/flex/tools/codecoverage/server/DataSocketReader.java
@@ -0,0 +1,88 @@
+/*
+ *
+ *  Licensed to the Apache Software Foundation (ASF) under one or more
+ *  contributor license agreements.  See the NOTICE file distributed with
+ *  this work for additional information regarding copyright ownership.
+ *  The ASF licenses this file to You under the Apache License, Version 2.0
+ *  (the "License"); you may not use this file except in compliance with
+ *  the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ *
+ */
+
+package org.apache.flex.tools.codecoverage.server;
+
+import java.io.BufferedReader;
+import java.io.BufferedWriter;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.net.Socket;
+
+/**
+ * Thread to read trace data from the Flex client. 
+ * All data read from the socket is written directly to the writer
+ * with no processing.
+ * 
+ */
+public class DataSocketReader implements Runnable 
+{
+    private Socket socket;
+    private BufferedWriter fileWriter;
+
+    /**
+     * Constructor.
+     * 
+     * @param socket The socket to read from.
+     * @param fileWriter The writer to write the data to.
+     */
+    public DataSocketReader(final Socket socket, final BufferedWriter fileWriter)
+    {
+        this.socket = socket;
+        this.fileWriter = fileWriter;
+    }
+    
+    /**
+     * Read data from the socket and write it the specified file until
+     * we are interrupted.
+     */
+    @Override
+    public void run() 
+    {
+        // listen for data
+        final char[] cbuf = new char[512 * 1024];
+        
+        try (BufferedReader in = new BufferedReader(
+                    new InputStreamReader(
+                        socket.getInputStream()), 512 * 1024))
+        {
+            while (!Thread.interrupted() && !socket.isClosed())
+            {
+                int charsRead = in.read(cbuf);
+                if (charsRead > 0)
+                {
+                    String buf = String.valueOf(cbuf, 0, charsRead);
+                    fileWriter.write(buf);  
+                }
+                else
+                {
+                    Thread.sleep(1000);
+                }
+            }
+        } 
+        catch (IOException e) 
+        {
+            e.printStackTrace();
+        }
+        catch (InterruptedException e) 
+        {
+        	// This happens when we are interrupted while sleeping.
+        }
+    }
+}

http://git-wip-us.apache.org/repos/asf/flex-utilities/blob/5077c457/CodeCoverage/JavaServer/java/src/org/apache/flex/tools/codecoverage/server/PolicyFileServer.java
----------------------------------------------------------------------
diff --git a/CodeCoverage/JavaServer/java/src/org/apache/flex/tools/codecoverage/server/PolicyFileServer.java
b/CodeCoverage/JavaServer/java/src/org/apache/flex/tools/codecoverage/server/PolicyFileServer.java
new file mode 100755
index 0000000..117249e
--- /dev/null
+++ b/CodeCoverage/JavaServer/java/src/org/apache/flex/tools/codecoverage/server/PolicyFileServer.java
@@ -0,0 +1,167 @@
+/*
+ *
+ *  Licensed to the Apache Software Foundation (ASF) under one or more
+ *  contributor license agreements.  See the NOTICE file distributed with
+ *  this work for additional information regarding copyright ownership.
+ *  The ASF licenses this file to You under the Apache License, Version 2.0
+ *  (the "License"); you may not use this file except in compliance with
+ *  the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ *
+ */
+
+package org.apache.flex.tools.codecoverage.server;
+
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.OutputStreamWriter;
+import java.net.ServerSocket;
+import java.net.Socket;
+import java.net.UnknownHostException;
+
+/**
+ * Thread to serve a policy file to the Flash Player to allow the Flash
+ * client to connect to the data port.
+ *
+ */
+public class PolicyFileServer implements Runnable 
+{
+    /**
+     * Request sent by the Flash Player requesting the policy file.
+     */
+    private static final String EXPECTED_REQUEST = "<policy-file-request/>";
+    
+    /**
+     * Template of the policy file. Variables in brackets are replaced with
+     * the actual values.
+     */
+    private static final String POLICY_FILE = "<?xml version=\"1.0\"?>" +  
+            "<!DOCTYPE cross-domain-policy SYSTEM \"http://www.adobe.com/xml/dtds/cross-domain-policy.dtd\">"
+ 
+            "<cross-domain-policy>" +  
+            "    <allow-access-from domain=\"{host}\" to-ports=\"{dataPort}\" />" +
+            "</cross-domain-policy>";
+
+    private final String host;
+    private final int dataPort;
+    private final int policyFilePort;
+    private boolean listening = true;
+    
+    // cached policy file create from the template.
+    private String policyFile;
+    
+    /**
+     * 
+     * @param host
+     * @param dataPort
+     * @param policyFilePort
+     */
+    public PolicyFileServer(final String host, final int dataPort, 
+            final int policyFilePort)
+    {
+        this.host = host;
+        this.dataPort = dataPort;
+        this.policyFilePort = policyFilePort;
+
+        initializePolicyFile();
+    }
+    
+    /**
+     * Wait for a connection on the policy file port. When a connection is received
+     * reply with a policy file if the Flash Player is requesting.
+     */
+    @Override
+    public void run() 
+    {
+        ServerSocket serverSocket = null;
+        
+        try
+        { 
+            // accept connections and return an in-memory policy file.
+            serverSocket = new ServerSocket(policyFilePort);
+
+            while (listening) 
+            {
+                try (Socket socket = serverSocket.accept())
+                {
+                    if (!listening)
+                        break;
+                    
+                    writePolicyFile(socket);
+                }
+            }
+        } 
+        catch (IOException e) 
+        {
+            e.printStackTrace();
+        }
+        finally 
+        {
+            if (serverSocket != null)
+            {
+                try 
+                {
+                    serverSocket.close();
+                } 
+                catch (IOException e1) 
+                {
+                    e1.printStackTrace();
+                }
+            }
+        }
+    }
+
+    /**
+     * Create the policy file from the template.
+     */
+    private void initializePolicyFile()
+    {
+        policyFile = POLICY_FILE.replace("{host}", host);
+        policyFile = policyFile.replace("{dataPort}", Integer.toString(dataPort));
+    }
+
+    /**
+     * Write the in-memory policy file to the socket.
+     * 
+     * @param socket Socket to write security policy file to.
+     */
+    private void writePolicyFile(final Socket socket)
+    {
+        char[] cbuf = new char[64];
+        
+        try (InputStreamReader reader = new InputStreamReader(socket.getInputStream());
+             OutputStreamWriter writer = new OutputStreamWriter(socket.getOutputStream()))
+        {
+            int result = reader.read(cbuf);
+            if (result > 0 && EXPECTED_REQUEST.equals(cbuf))
+            {
+                writer.write(policyFile);
+            }
+        } catch (IOException e)
+        {
+            e.printStackTrace();
+        }
+    }
+
+    /**
+     * Close the resources held by this thread.
+     * 
+     * @throws IOException 
+     * @throws UnknownHostException 
+     * @throws InterruptedException 
+     */
+    public void close() throws UnknownHostException, IOException, InterruptedException
+    {
+        // connect to socket to unblock the accept call
+        listening = false;
+        final Socket socket = new Socket(host, policyFilePort);
+        socket.close();
+    }
+    
+}


Mime
View raw message