openoffice-users mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From Marcin Tustin <>
Subject How to debug pyuno issues
Date Thu, 12 Dec 2013 20:39:24 GMT
I'd like to use openoffice to programmatically convert docx to pdf. I know
unoconv can do this, and indeed unoconv will do this for me, even if I run
a separate listener (using `unoconv -l`) and invoke `unoconv -n` (so that
it will die if it can't connect to the listener). Accordingly, I assume
that my openoffice/pyuno environment is sane.

However, when I run an unoconv listener (or manually invoke openoffice as
an acceptor), and try to connect with my own python code (derived from
unoconv, and cross-checked with another openoffice library), the listener
dies, and the uno bridge dies.

The error I get from the listener is:

    terminate called after throwing an instance of

The error I get on the python end is:

    unoconv: RuntimeException during import phase:
    Office probably died. Binary URP bridge disposed during call

I really have no idea how to go about diagnosing the problem here. Any
suggestions as to the underlying cause or how to diagnose it would be
greatly appreciated.

Code below:

#dependency on openoffice-python
import openoffice.streams as oostreams
import openoffice.officehelper as oohelper
import uno, unohelper
from import PropertyValue
from import NoConnectException
from import QUIET_UPDATE
from import DisposedException, IllegalArgumentException
from import IOException, XOutputStream
from import CannotConvertException
from import Exception as UnoException
from import RuntimeException

import logging
logger = logging.getLogger(__name__)

#connectionstring =
connectionstring = 'socket,host=,port=2002'
## context = uno.getComponentContext()
## svcmgr = context.ServiceManager
## resolver =

## unocontext = resolver.resolve("uno:%s" % connectionstring)
unocontext = oohelper.connect(connectionstring)

#unosvcmgr = unocontext.ServiceManager
desktop =

class OutputStream( unohelper.Base, XOutputStream ):
    def __init__(self, stream=None):
        self.closed = 0 = stream if stream is not None else sys.stdout

    def closeOutput(self):
        self.closed = 1

    def writeBytes( self, seq ): seq.value )

    def flush( self ):

def UnoProps(**args):
    props = []
    for key in args:
        prop = PropertyValue()
        prop.Name = key
        prop.Value = args[key]
    return tuple(props)

FILTERS = {'pdf': 'writer_pdf_Export'}

def convert_stream(instream, outstream,
                   outdoctype=None, outformat=None):
    '''instream and outstream are streams.
    outdoctype and outformat are strings. They correspond
    to the first two parameters to the Fmt constructor.To
    convert to pdf use outdoctype="document",
    If you choose inappropriate values, an ValueError
    will result.'''
    #fmts is a global object of type FmtList

    outputfilter = FILTERS[outformat]

    inputprops = UnoProps(Hidden=True, ReadOnly=True,
UpdateDocMode=QUIET_UPDATE, InputStream=oostreams.InputStream(instream))
    inputurl = 'private:stream'
    return outstream

def convert_worker(inputurl, inputprops, outputfilter,
    global exitcode

    document = None

        ### Import phase
        phase = "import"

        document = desktop.loadComponentFromURL( inputurl , "_blank", 0,
inputprops )

        if not document:
            raise UnoException("The document '%s' could not be opened." %
inputurl, None)

        ### Import style template
        phase = "import-style"

        ### Update document links
        phase = "update-links"
        except AttributeError:
            # the document doesn't implement the XLinkUpdate interface

        ### Update document indexes
        phase = "update-indexes"
        for ii in range(2):
            # At first update Table-of-Contents.
            # ToC grows, so page numbers grows too.
            # On second turn update page numbers in ToC.
                indexes = document.getDocumentIndexes()
            except AttributeError:
                # the document doesn't implement the XRefreshable and/or
                # XDocumentIndexesSupplier interfaces
                for i in range(0, indexes.getCount()):

        ### Export phase
        phase = "export"

        outputprops = UnoProps(FilterName=outputfilter,
OutputStream=OutputStream(stream=outstream), Overwrite=True)
        outputurl = "private:stream"

            document.storeToURL(outputurl, tuple(outputprops) )
        except IOException as e:
            raise UnoException("Unable to store document to %s (ErrCode
%d)\n\nProperties: %s" % (outputurl, e.ErrCode, outputprops), None)

        phase = "dispose"

    except SystemError as e:
        logger.error("unoconv: SystemError during %s phase:\n%s" % (phase,
        exitcode = 1

    except RuntimeException as e:
        logger.error("unoconv: RuntimeException during %s phase:\nOffice
probably died. %s" % (phase, e))
        exitcode = 6

    except DisposedException as e:
        logger.error("unoconv: DisposedException during %s phase:\nOffice
probably died. %s" % (phase, e))
        exitcode = 7

    except IllegalArgumentException as e:
        logger.error("UNO IllegalArgument during %s phase:\nSource file
cannot be read. %s" % (phase, e))
        exitcode = 8

    except IOException as e:
        #            for attr in dir(e): print '%s: %s', (attr, getattr(e,
        logger.error("unoconv: IOException during %s phase:\n%s" % (phase,
        exitcode = 3

    except CannotConvertException as e:
        #            for attr in dir(e): print '%s: %s', (attr, getattr(e,
        logger.error("unoconv: CannotConvertException during %s phase:\n%s"
% (phase, e.Message))
        exitcode = 4

    except UnoException as e:
        if hasattr(e, 'ErrCode'):
            logger.error("unoconv: UnoException during %s phase in %s
(ErrCode %d)" % (phase, repr(e.__class__), e.ErrCode))
            exitcode = e.ErrCode
        if hasattr(e, 'Message'):
            logger.error("unoconv: UnoException during %s phase:\n%s" %
(phase, e.Message))
            exitcode = 5
            logger.error("unoconv: UnoException during %s phase in %s" %
(phase, repr(e.__class__)))
            exitcode = 2

Marcin Tustin
Tel: +44 (0) 7773 787 105 (UK)
       +1  917 553 3974 (US)

  • Unnamed multipart/alternative (inline, None, 0 bytes)
View raw message