Etherpad Oo.org converter

importexport.scala

/**
 * Copyright 2009 Google Inc.
 * 
 * Licensed 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 com.etherpad.openofficeservice;

import net.appjet.common.sars.{SarsServer,SarsMessageHandler};

import java.io.{DataInputStream,DataOutputStream};
import java.io.{File,FileOutputStream,ByteArrayInputStream,ByteArrayOutputStream};

/* Libraries needed for OO.org Conversion */
import com.sun.star.bridge.{XBridge,XBridgeFactory};
import com.sun.star.beans.{PropertyValue,XPropertySet};
import com.sun.star.connection.{NoConnectException,XConnection,XConnector};
import com.sun.star.container.XNamed;
import com.sun.star.document.{XExporter,XFilter};
import com.sun.star.frame.{XComponentLoader,XStorable};
import com.sun.star.lang.{XComponent,XMultiComponentFactory};
import com.sun.star.uno.{UnoRuntime,XComponentContext};


class OOSException(m: String) extends RuntimeException(m);
class UnsupportedFormatException(format: String) extends OOSException("Unsupported format: "+format);
object TemporaryFailure extends OOSException("Temporary failure");


object OpenOfficeServerUtility {
  def checkServerAvailability(host: String, port: Int): Boolean = {
    return true;
    // Rather than checking, lets assume that server is running till I finish coding.
    // May be, I will implement this in future
  }
  def runOpenOfficeServer(path: String, host: String, port: Int, timeout: Int, wait: Boolean) {
    // Rather than running it from here, lets assume that the admin will run it.
    // May be, I will implement this in future
  }
}

class OpenOfficeFileConverter {
  var host: String = "localhost";
  var port: Int = 8100;

  def setOpenOfficeServerDetails(host: String, port: Int) {
    this.host = host;
    this.port = port;
  }
  
  def convertFile(src: File, dst: File, converter: String, extension: String): Boolean = {
    try {
      val fromFile: String = "file:///" + src.getAbsolutePath();
      val toFile: String = "file:///" + dst.getAbsolutePath();

      val cnx: String = "socket,host="+this.host+",port="+this.port+"";
      val xRemoteContext: XComponentContext  = com.sun.star.comp.helper.Bootstrap.createInitialComponentContext(null);
      val x: Object = xRemoteContext.getServiceManager().createInstanceWithContext("com.sun.star.connection.Connector", xRemoteContext);
      val xConnector: XConnector  = UnoRuntime.queryInterface(classOf[XConnector], x).asInstanceOf[XConnector];
      val connection: XConnection  = xConnector.connect(cnx);
    
      if(connection == null) {
        throw new OOSException("Connection failure");
      }
      val x2: Object = xRemoteContext.getServiceManager().createInstanceWithContext("com.sun.star.bridge.BridgeFactory", xRemoteContext);      
      val xBridgeFactory: XBridgeFactory = UnoRuntime.queryInterface(classOf[XBridgeFactory], x2).asInstanceOf[XBridgeFactory];
      val xBridge: XBridge = xBridgeFactory.createBridge("", "urp", connection, null);
      val x3: Object = xBridge.getInstance("StarOffice.ServiceManager");
      if (x3 == null) {
        throw new OOSException("Failed to get bridge");
      }
    
      val xMultiComponentFactory: XMultiComponentFactory  = UnoRuntime.queryInterface(classOf[XMultiComponentFactory], x3).asInstanceOf[XMultiComponentFactory];
      val xProperySet: XPropertySet  = UnoRuntime.queryInterface(classOf[XPropertySet], xMultiComponentFactory).asInstanceOf[XPropertySet];
      val oDefaultContext: Object  = xProperySet.getPropertyValue("DefaultContext");
      val xComponentContext: XComponentContext = UnoRuntime.queryInterface(classOf[XComponentContext], oDefaultContext).asInstanceOf[XComponentContext];
    
      val desktopObj: Object  = xMultiComponentFactory.createInstanceWithContext("com.sun.star.frame.Desktop", xComponentContext);
      val xcomponentloader: XComponentLoader = UnoRuntime.queryInterface(classOf[XComponentLoader], desktopObj).asInstanceOf[XComponentLoader];
    
      if(xcomponentloader == null) {
        throw new OOSException("XComponent Loader could not be loaded");
      }
    
      val loadProps: Array[PropertyValue] = new Array[PropertyValue](2);    
      loadProps(0) = new PropertyValue();
      loadProps(0).Name = "Hidden";
      loadProps(0).Value = boolean2Boolean(false);

      loadProps(1) = new PropertyValue();
      loadProps(1).Name = "UpdateDocMode";
      loadProps(1).Value = "1";

      val component: XComponent = xcomponentloader.loadComponentFromURL(fromFile,"_blank", 0, loadProps);
        
      if (component == null) {
  			throw new OOSException("Failed to load document");
  		}
		
  		val convProps: Array[PropertyValue] = new Array[PropertyValue](2);    	
      convProps(0) = new PropertyValue();
      convProps(0).Name = "FilterName";
      convProps(0).Value = converter;
    
      val xstorable: XStorable = UnoRuntime.queryInterface(classOf[XStorable],component).asInstanceOf[XStorable];
      if (xstorable == null) {
          throw new OOSException("Storable could not be loaded");
      }
      xstorable.storeToURL(toFile, convProps);
      component.dispose();
      return true;
    }
    catch {
      case e => {
  	    e.printStackTrace();
  		  throw new OOSException("Unknown exception occurred: "+e.getMessage());
		  }
    }
    return false;
  }
}

object OpenOfficeService {
  val formats = Map(
    "pdf" -> "writer_pdf_Export",
    "doc" -> "MS Word 97",
    "html" -> "HTML (StarWriter)",
    "odt" -> "writer8",
    "txt" -> "Text"
  );
  
  def createTempFile(bytes: Array[byte], suffix: String) = {
    var f = File.createTempFile("ooconvert-", if (suffix == null) { null } else if (suffix == "") { "" } else { "."+suffix });
  	if (bytes != null) {
  		val fos = new FileOutputStream(f);
  		fos.write(bytes);		
  	}
  	f;
  }

  var soffice = "soffice";
  def setExecutable(exec: String) {
    soffice = exec;
  }
  
  var openOfficeServerHost: String = "localhost";
	var openOfficeServerPort: Int = 8100;
  
  def setOpenOfficeServer(host: String, port: Int) {
    openOfficeServerHost = host;
    openOfficeServerPort = port;
  }

  def convertFile(from: String, to: String, bytes: Array[byte]): Array[byte] = {
    if (from == to) {
      return bytes;
    }

  	val tempFile = createTempFile(bytes, from);
  	val outFile = createTempFile(null, to);

  	/*
  	 Just hardcoding server and port here.
  	 If you intend to use an Openoffice.org instance on a network machine,
  	 do it at your risk. 
  	 
  	 Just, remember to setOpenOfficeServer from etherpad/importexport/importexport.js,
  	 Also, remember that OO.org is reading and writing files over file:/// URI. So, make sure that 
  	 you can access the files from network machine. Hint, NFS. Not Need for Speed game, you idiot,
  	 Network File System.
  	  
  	*/
  	
  	if (! OpenOfficeServerUtility.checkServerAvailability(openOfficeServerHost, openOfficeServerPort)) {
  		try {
  			OpenOfficeServerUtility.runOpenOfficeServer(soffice, openOfficeServerHost, openOfficeServerPort, 20000, true);
  		} catch {
  		  case e: java.io.IOException => {
  		    e.printStackTrace();
  		    throw TemporaryFailure;
    		}
  		}
  	}
  	var converter = new OpenOfficeFileConverter();
  	converter.setOpenOfficeServerDetails(openOfficeServerHost, openOfficeServerPort);
  	var status = false;
  	try {
  		status = converter.convertFile(tempFile, outFile, formats(to), to);
  	} catch {
  	  case e => {
  	    e.printStackTrace();
  		  throw new OOSException("Unknown exception occurred: "+e.getMessage());
		  }
  	}
  	if (status == false) {
  	  throw new UnsupportedFormatException(from);
  	}
  	net.appjet.common.util.BetterFile.getFileBytes(outFile);
  }

  def main(args: Array[String]) {
    if (args.length > 0) {
      soffice = args(0);
      if (soffice.length == 0) {
        exit(1);
      }
    }
    
    // Query format:
    // from: String, to: String, count: Int, bytes: Array[byte]
    // Response format:
    // status: Int, <data>
    //   status 0 (success) - <data>: count: Int, bytes: Array[byte]
    //   status 1 (temporary failure) - <data>: <none>
    //   status 2 (permanent failure) - <data>: type: Int
    //               type - 0: unknown failure.
    //                    - 1: unsupported format
    val handler = new SarsMessageHandler {
      override def handle(b: Array[byte]): Option[Array[byte]] = {
        val is = new DataInputStream(new ByteArrayInputStream(b));
        val from = is.readUTF;
        val to = is.readUTF;
        val len = is.readInt;
        val bytes = new Array[byte](len);
        is.readFully(bytes);
        var status = 0;
        var permfailuretype = 0;
        
        println("Converting "+from+" -> "+to+" ("+len+" bytes)");
        
        val output = try {
          convertFile(from, to, bytes);
        } catch {
          case TemporaryFailure => {
            status = 1;
            null;
          }
          case e: UnsupportedFormatException => {
            status = 2;
            permfailuretype = 1;
            null;
          }
          case e => {
            status = 2;
            permfailuretype = 0;
            e.printStackTrace();
            null;
          }
        }
        
        val retBytes = new ByteArrayOutputStream();
        val ret = new DataOutputStream(retBytes);
        if (status != 0) {
          ret.writeInt(status); // error
          status match {
            case 2 => {
              ret.writeInt(permfailuretype);
            }
            case _ => { }
          }
        } else {
          ret.writeInt(0); // success
          ret.writeInt(output.length);
          ret.write(output, 0, output.length);
        }
        Some(retBytes.toByteArray());
      }
    }
    
    val server = new SarsServer("ooffice-password", handler, None, 8101);
    server.start();
    println("Server running...");
    server.join();
    println("Server quitting...");
  }
}