| # Copyright 2018 IBM Corporation |
| # |
| # 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. |
| import functools |
| import json |
| import marshal |
| import base64 |
| import types |
| |
| # dummy composition and compiler |
| composition = {} # will be overridden |
| class Compiler: |
| def lower(self, composition, combinators = []): |
| pass |
| def deserialize(self, composition): |
| pass |
| def label(self, composition): |
| pass |
| |
| def conductor(): |
| global composition |
| compiler = Compiler() |
| |
| def chain(front, back): |
| front[-1]['next'] = 1 |
| front.extend(back) |
| return front |
| |
| def sequence(components): |
| if len(components) == 0: |
| return [{ 'type': 'empty' }] |
| return functools.reduce(chain, map(compile, components)) |
| |
| def compile(json): |
| path = json.path if hasattr(json, 'path') else None |
| type_ = json.type |
| if type_ == 'sequence': |
| return chain([{ 'type': 'pass', 'path':path }], sequence(json.components)) |
| elif type_ == 'action': |
| return [{ 'type': 'action', 'name': json.name, 'path': path }] |
| elif type_ == 'function': |
| return [{ 'type': 'function', 'exec': json.function['exec'], 'path':path }] |
| elif type_ == 'finally': |
| body = compile(json.body) |
| finalizer = compile(json.finalizer) |
| fsm = functools.reduce(chain, [[{'type': 'try', 'path': path}], body, [{ 'type': 'exit' }], finalizer]) |
| fsm[0]['catch'] = len(fsm) - len(finalizer) |
| return fsm |
| elif type_ == 'let': |
| body = sequence(json.components) |
| return functools.reduce(chain, [[{ 'type': 'let', 'let': json.declarations, 'path':path }], body, [{ 'type': 'exit' }]]) |
| elif type_ == 'mask': |
| body = sequence(json.components) |
| return functools.reduce(chain, [[{ 'type': 'let', 'let': None, 'path': path }], body, [{ 'type': 'exit' }]]) |
| elif type_ == 'try': |
| body = compile(json.body) |
| handler = chain(compile(json.handler), [{ 'type': 'pass' }]) |
| fsm = functools.reduce(chain, [[{ 'type': 'try', 'path':path }], body, [{ 'type': 'exit' }]]) |
| fsm[0]['catch'] = len(fsm) |
| fsm[-1]['next'] = len(handler) |
| fsm.extend(handler) |
| return fsm |
| elif type_ == 'if_nosave': |
| consequent = compile(json.consequent) |
| alternate = chain(compile(json.alternate), [{ 'type': 'pass' }]) |
| fsm = functools.reduce(chain, [[{ 'type': 'pass', 'path':path }], compile(json.test), [{ 'type': 'choice', 'then': 1, 'else': len(consequent) + 1 }]]) |
| consequent[-1]['next'] = len(alternate) |
| fsm.extend(consequent) |
| fsm.extend(alternate) |
| return fsm |
| elif type_ == 'while_nosave': |
| consequent = compile(json.body) |
| alternate = [{ 'type': 'pass' }] |
| fsm = functools.reduce(chain, [[{ 'type': 'pass', 'path':path }], compile(json.test), [{ 'type': 'choice', 'then': 1, 'else': len(consequent) + 1 }]]) |
| consequent[-1]['next'] = 1 - len(fsm) - len(consequent) |
| fsm.extend(consequent) |
| fsm.extend(alternate) |
| return fsm |
| elif type_ == 'dowhile_nosave': |
| test = compile(json.test) |
| fsm = functools.reduce(chain, [[{ 'type': 'pass', 'path':path }], compile(json.body), test, [{ 'type': 'choice', 'then': 1, 'else': 2 }]]) |
| fsm[-1]['then'] = 1 - len(fsm) |
| fsm[-1]['else'] = 1 |
| alternate = [{ 'type': 'pass' }] |
| fsm.extend(alternate) |
| return fsm |
| |
| fsm = compile(compiler.lower(compiler.label(compiler.deserialize(composition)))) |
| |
| isObject = lambda x: isinstance(x, dict) |
| |
| def encodeError(error): |
| if isinstance(error, str) or not hasattr(error, "__getitem__"): |
| return { |
| 'code': 500, |
| 'error': error |
| } |
| else: |
| return { |
| 'code': error['code'] if isinstance(error['code'], int) else 500, |
| 'error': error['error'] if isinstance(error['error'], str) else (error['message'] if 'message' in error else 'An internal error occurred') |
| } |
| |
| # error status codes |
| badRequest = lambda error: { 'code': 400, 'error': error } |
| internalError = lambda error: encodeError(error) |
| |
| def guarded_invoke(params): |
| try: |
| return invoke(params) |
| except Exception as err: |
| return internalError(err) |
| |
| def invoke(params): |
| ''' do invocation ''' |
| # initial state and stack |
| state = 0 |
| stack = [] |
| |
| # wrap params if not a dictionary, branch to error handler if error |
| def inspect_errors(): |
| nonlocal params |
| nonlocal state |
| nonlocal stack |
| params = params if isObject(params) else { 'value': params } |
| if 'error' in params: |
| params = { 'error': params['error'] } # discard all fields but the error field |
| state = None # abort unless there is a handler in the stack |
| while len(stack) > 0: |
| first = stack[0] |
| stack = stack[1:] |
| if 'catch' in first: |
| state = first['catch'] |
| if isinstance(state, int): |
| break |
| |
| |
| # restore state and stack when resuming |
| if '$resume' in params: |
| if not isObject(params['$resume']): |
| return badRequest('The type of optional $resume parameter must be object') |
| if not 'state' in params['$resume'] and not isinstance(params['$resume']['state'], int): |
| return badRequest('The type of optional $resume["state"] parameter must be number') |
| state = params['$resume']['state'] |
| stack = params['$resume']['stack'] |
| if not isinstance(stack, list): |
| return badRequest('The type of $resume["stack"] must be an array') |
| del params['$resume'] |
| inspect_errors() # handle error objects when resuming |
| |
| # run function f on current stack |
| def run(f, kind, functionName=None): |
| # handle let/mask pairs |
| view = [] |
| n = 0 |
| for frame in stack: |
| if 'let' in frame and frame['let'] is None: |
| n += 1 |
| elif 'let' in frame: |
| if n == 0: |
| view.append(frame) |
| else: |
| n -= 1 |
| |
| |
| # update value of topmost matching symbol on stack if any |
| def set(symbol, value): |
| lets = [element for element in view if 'let' in element and symbol in element['let']] |
| if len(lets) > 0: |
| element = lets[0] |
| element['let'][symbol] = value # TODO: JSON.parse(JSON.stringify(value)) |
| |
| |
| def reduceRight(func, init, seq): |
| if not seq: |
| return init |
| else: |
| return func(reduceRight(func, init, seq[1:]), seq[0]) |
| |
| def update(dict, dict2): |
| dict.update(dict2) |
| return dict |
| |
| # collapse stack for invocation |
| env = reduceRight(lambda acc, cur: update(acc, cur['let']) if 'let' in cur and isinstance(cur['let'], dict) else acc, {}, view) |
| if kind == 'python:3': |
| main = '''exec(code + "\\n__out__['value'] = ''' + functionName + '''(env, args)", {'env': env, 'args': args, '__out__':__out__})''' |
| code = f |
| else: # lambda |
| main = '''__out__['value'] = code(env, args)''' |
| code = types.FunctionType(marshal.loads(base64.b64decode(bytearray(f, 'ASCII'))), {}) |
| |
| try: |
| out = {'value': None} |
| exec(main, {'env': env, 'args': params, 'code': code, '__out__': out}) |
| return out['value'] |
| finally: |
| for name in env: |
| set(name, env[name]) |
| |
| while True: |
| # final state, return composition result |
| if state is None: |
| print('Entering final state') |
| print(json.dumps(params)) |
| if 'error' in params: |
| return params |
| else: |
| return { 'params': params } |
| |
| # process one state |
| jsonv = fsm[state] # jsonv definition for current state |
| if 'path' in jsonv: |
| print('Entering composition'+jsonv['path']) |
| current = state |
| state = current + jsonv['next'] if 'next' in jsonv else None # default next state |
| if jsonv['type'] == 'choice': |
| state = current + (jsonv['then'] if params['value'] else jsonv['else']) |
| elif jsonv['type'] == 'try': |
| stack.insert(0, { 'catch': current + jsonv['catch'] }) |
| elif jsonv['type'] == 'let': |
| stack.insert(0, { 'let': jsonv['let'] }) # JSON.parse(JSON.stringify(jsonv.let)) |
| elif jsonv['type'] == 'exit': |
| if len(stack) == 0: |
| return internalError('State '+str(current)+' attempted to pop from an empty stack') |
| stack = stack[1:] |
| elif jsonv['type'] == 'action': |
| return { 'action': jsonv['name'], 'params': params, 'state': { '$resume': { 'state': state, 'stack': stack } } } # invoke continuation |
| elif jsonv['type'] == 'function': |
| result = None |
| try: |
| functionName = jsonv['exec']['functionName'] if 'functionName' in jsonv['exec'] else None |
| result = run(jsonv['exec']['code'], jsonv['exec']['kind'], functionName) |
| except Exception as error: |
| print(error) |
| result = { 'error': 'An exception was caught at state '+str(current)+' (see log for details)' } |
| |
| if callable(result): |
| result = { 'error': 'State '+str(current)+' evaluated to a function' } |
| |
| # if a function has only side effects and no return value (or return None), return params |
| params = params if result is None else result |
| inspect_errors() |
| elif jsonv['type'] == 'empty': |
| inspect_errors() |
| elif jsonv['type'] == 'pass': |
| pass |
| else: |
| return internalError('State '+str(current)+ 'has an unknown type') |
| |
| return guarded_invoke |
| |
