|
|
|
|
|
import logging |
|
|
import sys |
|
|
import os |
|
|
|
|
|
logfmt = logging.Formatter((' backend %5d ' % os.getpid()) |
|
|
+'%(message)s') |
|
|
logger = logging.getLogger('backend') |
|
|
logger.setLevel(logging.INFO) |
|
|
|
|
|
|
|
|
logger.info('backend: %s', os.getpid()) |
|
|
logger.info('sys.executable = %s', sys.executable) |
|
|
|
|
|
import unohelper |
|
|
g_ImplementationHelper = unohelper.ImplementationHelper() |
|
|
|
|
|
def implementation(component_name, *services): |
|
|
def decorator(cls): |
|
|
g_ImplementationHelper.addImplementation(cls, component_name, services) |
|
|
return cls |
|
|
return decorator |
|
|
|
|
|
|
|
|
from com.sun.star.task import XJob |
|
|
|
|
|
@implementation('backend.TestRunnerJob') |
|
|
class TestRunnerJob(unohelper.Base, XJob): |
|
|
|
|
|
def __init__(self, context): |
|
|
self.context = context |
|
|
|
|
|
def execute(self, arguments): |
|
|
import sys |
|
|
args = dict((nv.Name, nv.Value) for nv in arguments) |
|
|
|
|
|
cwd = os.getcwd() |
|
|
working_dir = args['working_dir'] |
|
|
os.chdir(working_dir) |
|
|
try: |
|
|
logstream = args['logstream'] |
|
|
logstream = FileFromStream(logstream) |
|
|
loghandler = logging.StreamHandler(logstream) |
|
|
loghandler.setFormatter(logfmt) |
|
|
logger.addHandler(loghandler) |
|
|
try: |
|
|
logger.info('current dir: %s', cwd) |
|
|
logger.info('working dir: %s', working_dir) |
|
|
logger.info('sys.path:') |
|
|
for x in sys.path: |
|
|
logger.info('- %s', x) |
|
|
return self.run(args) |
|
|
finally: |
|
|
logger.removeHandler(loghandler) |
|
|
finally: |
|
|
os.chdir(cwd) |
|
|
|
|
|
def run(self, args): |
|
|
import cPickle |
|
|
outstream = args.get('outputstream') |
|
|
outstream = FileFromStream(outstream) |
|
|
|
|
|
extra_path = args.get('extra_path') |
|
|
if extra_path: |
|
|
logger.info('extra_path: %s', ' '.join(extra_path)) |
|
|
sys.path.extend(extra_path) |
|
|
|
|
|
logconf_path = args.get('logconf_path') |
|
|
if logconf_path: |
|
|
import logging.config |
|
|
logging.config.fileConfig(logconf_path) |
|
|
|
|
|
from hwp5.plat import _uno |
|
|
_uno.enable() |
|
|
|
|
|
pickled_testsuite = args.get('pickled_testsuite') |
|
|
if not pickled_testsuite: |
|
|
logger.error('pickled_testsuite is required') |
|
|
return cPickle.dumps(dict(successful=False, tests=0, failures=0, |
|
|
errors=0)) |
|
|
|
|
|
pickled_testsuite = str(pickled_testsuite) |
|
|
testsuite = cPickle.loads(pickled_testsuite) |
|
|
logger.info('Test Suite Unpickled') |
|
|
|
|
|
from unittest import TextTestRunner |
|
|
testrunner = TextTestRunner(stream=outstream) |
|
|
result = testrunner.run(testsuite) |
|
|
result = dict(successful=result.wasSuccessful(), |
|
|
tests=result.testsRun, |
|
|
failures=list(str(x) for x in result.failures), |
|
|
errors=list(str(x) for x in result.errors)) |
|
|
return cPickle.dumps(result) |
|
|
|
|
|
|
|
|
import contextlib |
|
|
|
|
|
|
|
|
@contextlib.contextmanager |
|
|
def sandbox(working_dir, **kwargs): |
|
|
import os |
|
|
import sys |
|
|
|
|
|
backup = dict() |
|
|
class NOTHING: |
|
|
pass |
|
|
if not hasattr(sys, 'argv'): |
|
|
sys.argv = NOTHING |
|
|
|
|
|
NAMES = ['path', 'argv', 'stdin', 'stdout', 'stderr'] |
|
|
for x in NAMES: |
|
|
assert x in kwargs |
|
|
|
|
|
backup['cwd'] = os.getcwd() |
|
|
os.chdir(working_dir) |
|
|
for x in NAMES: |
|
|
backup[x] = getattr(sys, x) |
|
|
setattr(sys, x, kwargs[x]) |
|
|
|
|
|
try: |
|
|
yield |
|
|
finally: |
|
|
for x in NAMES: |
|
|
setattr(sys, x, backup[x]) |
|
|
os.chdir(backup['cwd']) |
|
|
|
|
|
if sys.argv is NOTHING: |
|
|
del sys.argv |
|
|
|
|
|
|
|
|
@implementation('backend.RemoteRunJob') |
|
|
class RemoteRunJob(unohelper.Base, XJob): |
|
|
|
|
|
def __init__(self, context): |
|
|
self.context = context |
|
|
|
|
|
def execute(self, arguments): |
|
|
args = dict((nv.Name, nv.Value) for nv in arguments) |
|
|
|
|
|
logpath = args.get('logfile') |
|
|
if logpath is not None: |
|
|
logfile = file(logpath, 'a') |
|
|
loghandler = logging.StreamHandler(logfile) |
|
|
logger.addHandler(loghandler) |
|
|
|
|
|
import datetime |
|
|
logger.info('-'*10 + (' start at %s' % datetime.datetime.now()) + '-'*10) |
|
|
try: |
|
|
return self.run(args) |
|
|
finally: |
|
|
logger.info('-'*10 + (' stop at %s' % datetime.datetime.now()) + '-'*10) |
|
|
if logpath is not None: |
|
|
logger.removeHandler(loghandler) |
|
|
|
|
|
def run(self, args): |
|
|
import cPickle |
|
|
|
|
|
working_dir = args['working_dir'] |
|
|
path = cPickle.loads(str(args['path'])) |
|
|
argv = cPickle.loads(str(args['argv'])) |
|
|
stdin = FileFromStream(args['stdin']) |
|
|
stdout = FileFromStream(args['stdout']) |
|
|
stderr = FileFromStream(args['stderr']) |
|
|
|
|
|
script = argv[0] |
|
|
with sandbox(working_dir, path=path, argv=argv, stdin=stdin, |
|
|
stdout=stdout, stderr=stderr): |
|
|
g = dict(__name__='__main__') |
|
|
try: |
|
|
execfile(script, g) |
|
|
except SystemExit, e: |
|
|
return e.code |
|
|
except Exception, e: |
|
|
logger.exception(e) |
|
|
raise |
|
|
except: |
|
|
import traceback |
|
|
logger.error('%s' % traceback.format_exc()) |
|
|
raise |
|
|
|
|
|
|
|
|
@implementation('backend.ConsoleJob') |
|
|
class ConsoleJob(unohelper.Base, XJob): |
|
|
|
|
|
def __init__(self, context): |
|
|
self.context = context |
|
|
|
|
|
def execute(self, arguments): |
|
|
args = dict((nv.Name, nv.Value) for nv in arguments) |
|
|
|
|
|
cwd = os.getcwd() |
|
|
try: |
|
|
inp = args['inp'] |
|
|
outstream = args['outstream'] |
|
|
|
|
|
outfile = FileFromStream(outstream) |
|
|
|
|
|
import sys |
|
|
orig = sys.stdout, sys.stderr |
|
|
sys.stdout = sys.stderr = outfile |
|
|
try: |
|
|
console = Console(inp, outfile) |
|
|
try: |
|
|
console.interact('LibreOffice Python Console (pid: %s)' % |
|
|
os.getpid()) |
|
|
return 0 |
|
|
except SystemExit, e: |
|
|
return e.code |
|
|
finally: |
|
|
sys.stdout, sys.stderr = orig |
|
|
finally: |
|
|
os.chdir(cwd) |
|
|
|
|
|
|
|
|
from code import InteractiveConsole |
|
|
class Console(InteractiveConsole): |
|
|
|
|
|
def __init__(self, inp, outfile): |
|
|
InteractiveConsole.__init__(self) |
|
|
self.inp = inp |
|
|
self.outfile = outfile |
|
|
|
|
|
def write(self, data): |
|
|
self.outfile.write(data) |
|
|
self.outfile.flush() |
|
|
|
|
|
def raw_input(self, prompt=''): |
|
|
import uno |
|
|
arg = uno.createUnoStruct('com.sun.star.beans.NamedValue') |
|
|
arg.Name = 'prompt' |
|
|
arg.Value = prompt |
|
|
args = arg, |
|
|
result = self.inp.execute(args) |
|
|
if result is None: |
|
|
raise EOFError() |
|
|
return result |
|
|
|
|
|
|
|
|
class FileFromStream(object): |
|
|
''' A file-like object based on XInputStream/XOuputStream/XSeekable |
|
|
|
|
|
:param stream: a stream object which implements |
|
|
com.sun.star.io.XInputStream, com.sun.star.io.XOutputStream or |
|
|
com.sun.star.io.XSeekable |
|
|
''' |
|
|
def __init__(self, stream, encoding='utf-8'): |
|
|
import uno |
|
|
self.stream = stream |
|
|
self.encoding = encoding |
|
|
|
|
|
if hasattr(stream, 'readBytes'): |
|
|
def read(size=None): |
|
|
if size is None: |
|
|
data = '' |
|
|
while True: |
|
|
bytes = uno.ByteSequence('') |
|
|
n_read, bytes = stream.readBytes(bytes, 4096) |
|
|
if n_read == 0: |
|
|
return data |
|
|
data += bytes.value |
|
|
bytes = uno.ByteSequence('') |
|
|
n_read, bytes = stream.readBytes(bytes, size) |
|
|
return bytes.value |
|
|
self.read = read |
|
|
|
|
|
if hasattr(stream, 'seek'): |
|
|
self.tell = stream.getPosition |
|
|
|
|
|
def seek(offset, whence=0): |
|
|
if whence == 0: |
|
|
pass |
|
|
elif whence == 1: |
|
|
offset += stream.getPosition() |
|
|
elif whence == 2: |
|
|
offset += stream.getLength() |
|
|
stream.seek(offset) |
|
|
self.seek = seek |
|
|
|
|
|
if hasattr(stream, 'writeBytes'): |
|
|
def write(s): |
|
|
if isinstance(s, unicode): |
|
|
s = s.encode(self.encoding) |
|
|
stream.writeBytes(uno.ByteSequence(s)) |
|
|
self.write = write |
|
|
|
|
|
def flush(): |
|
|
stream.flush() |
|
|
self.flush = flush |
|
|
|
|
|
def close(self): |
|
|
if hasattr(self.stream, 'closeInput'): |
|
|
self.stream.closeInput() |
|
|
elif hasattr(self.stream, 'closeOutput'): |
|
|
self.stream.closeOutput() |
|
|
|
|
|
|
|
|
''' |
|
|
import os.path |
|
|
from uno import systemPathToFileUrl |
|
|
from unokit.ucb import open_url |
|
|
from unokit.services import css |
|
|
|
|
|
path = os.path.abspath('samples/sample-5017.hwp') |
|
|
print path |
|
|
url = systemPathToFileUrl(path) |
|
|
print url |
|
|
inp = open_url(url) |
|
|
print inp |
|
|
|
|
|
# 여기서 segfault |
|
|
stg = css.embed.OLESimpleStorage(inp) |
|
|
print stg |
|
|
''' |
|
|
|
|
|
|
|
|
''' |
|
|
SegFault가 나는 stacktrace는 다음과 같다 |
|
|
|
|
|
StgDirEntry::StgDirEntry |
|
|
sot/source/sdstor/ |
|
|
StgEntry::Load |
|
|
sot/source/sdstor/ |
|
|
ToUpperUnicode |
|
|
sot/source/sdstor/stgelem.cxx |
|
|
CharClass |
|
|
unotools/source/i18n/charclass.cxx |
|
|
intl_createInstance |
|
|
unotools/source/i18n/instance.hxx |
|
|
|
|
|
여기서 ::comphelper::getProcessServiceFactory로 얻은 XMultiServiceFactory가 |
|
|
null 값인 것 같다. |
|
|
|
|
|
---- |
|
|
|
|
|
uno를 사용하는 프로그램들 (desktop app/unopkg, 각종 unittest 프로그램)은 |
|
|
처음 실행 시 다음과 같은 과정을 거치는 듯 하다. |
|
|
|
|
|
1. ::cppu::defaultBootstrap_InitialComponentContext()을 호출, local context 생성 |
|
|
- unorc 등을 검색, application.rdb, user.rdb 등에 접근 |
|
|
|
|
|
- pyuno.so 의 getComponentContext()에서 수행: PYUNOLIBDIR 즉 pyuno.so가 있는 |
|
|
디렉토리에서 pyuno.rc가 있으면 그것으로 초기화) |
|
|
- desktop app: appinit.cxx의 CreateApplicationServiceManager()에서 수행 |
|
|
- unopkg: unopkg_misc.cxx의 bootstrapStandAlone()에서 수행. |
|
|
ucbhelper::ContentBroker도 함께 초기화한다. |
|
|
|
|
|
2. 이렇게 생성한 local context로부터 ServiceManager를 얻어 |
|
|
::comphelper::setProcessServiceFactory()를 사용하여 프로세스 전역 service |
|
|
factory로 등록 |
|
|
|
|
|
- uno.py와 pyuno.so는 이 작업을 하지 않는다. |
|
|
- desktop app: app.cxx의 ensureProcessServiceFactory()에서 수행 |
|
|
- unopkg: unopkg_misc.cxx의 bootstrapStandAlone()에서 함께 수행. |
|
|
|
|
|
|
|
|
* desktop app: desktop/source/app/ |
|
|
* unopkg: desktop/source/pkgchk/unopkg/ |
|
|
|
|
|
''' |
|
|
|
|
|
logger.info('%s: end of file', __name__) |
|
|
|
