Пример #1
0
def do(data, resource):
    partition = 'logic-function'
    body = {}
    params = data['params']

    function_name = params.get('function_name')
    description = params.get('description', None)
    zip_file = params.get('zip_file', None)
    runtime = params.get('runtime', None)
    handler = params.get('handler', None)
    runnable = params.get('runnable', None)
    sdk_config = params.get('sdk_config', None)

    items, _ = resource.db_query(partition, [{
        'option': None,
        'field': 'function_name',
        'condition': 'eq',
        'value': function_name
    }])

    if items:
        item = items[0]
        if description:
            item['description'] = description
        if handler:
            item['handler'] = handler
        if runtime:
            item['runtime'] = runtime
        if runnable is not None:
            item['runnable'] = runnable
        if sdk_config is not None:
            item['sdk_config'] = sdk_config
        if zip_file:
            zip_file_id = uuid()
            requirements_zip_file_id = uuid()
            zip_file_b64 = zip_file.encode('utf-8')
            zip_file_bin = base64.b64decode(zip_file_b64)
            requirements_zip_file_bin = generate_requirements_zipfile(
                zip_file_bin)
            resource.file_upload_bin(zip_file_id, zip_file_bin)
            resource.file_upload_bin(requirements_zip_file_id,
                                     requirements_zip_file_bin)
            item['zip_file_id'] = zip_file_id
            item['requirements_zip_file_id'] = requirements_zip_file_id

        resource.db_update_item(item['id'], item)
        body['function_name'] = function_name
        return Response(body)
    else:
        body['error'] = error.NO_SUCH_FUNCTION
        return Response(body)
Пример #2
0
def do(data, resource):
    partition = 'logic-function'
    body = {}
    params = data['params']

    function_name = params.get('function_name')
    description = params.get('description', None)
    zip_file = params.get('zip_file', None)
    runtime = params.get('runtime')
    handler = params.get('handler')
    runnable = params.get('runnable', True)
    sdk_config = params.get('sdk_config', {})

    zip_file_id = uuid()
    requirements_zip_file_id = uuid()

    item = dict()
    item['function_name'] = function_name
    item['description'] = description
    item['handler'] = handler
    item['runtime'] = runtime
    item['runnable'] = runnable
    item['zip_file_id'] = zip_file_id
    item['requirements_zip_file_id'] = requirements_zip_file_id
    item['sdk_config'] = sdk_config

    item_ids, _ = resource.db_get_item_id_and_orders(partition,
                                                     'function_name',
                                                     function_name)
    if len(item_ids) == 0:
        zip_file_b64 = zip_file.encode('utf-8')
        zip_file_bin = base64.b64decode(zip_file_b64)
        requirements_zip_file_bin = generate_requirements_zipfile(zip_file_bin)
        resource.file_upload_bin(zip_file_id, zip_file_bin)
        resource.file_upload_bin(requirements_zip_file_id,
                                 requirements_zip_file_bin)
        resource.db_put_item(partition, item)
        body['function_name'] = function_name
        return body
    else:
        body['error'] = error.EXISTING_FUNCTION
        return body
Пример #3
0
def do(data, resource):
    partition = 'logic-function'
    body = {}
    params = data['params']

    function_name = params.get('function_name')
    file_path = params.get('file_path')
    file_content = params.get('file_content')
    file_type = params.get('file_type', 'text')

    print(params)

    if file_type not in SUPPORT_TYPES:
        body['error'] = error.UNSUPPORTED_FILE_TYPE
        return body

    items, _ = resource.db_query(partition, [{
        'option': None,
        'field': 'function_name',
        'value': function_name,
        'condition': 'eq'
    }])

    if len(items) == 0:
        body['message'] = 'function_name: {} did not exist'.format(
            function_name)
        return body
    else:
        item = items[0]
        zip_file_id = item['zip_file_id']
        zip_file_bin = resource.file_download_bin(zip_file_id)
        zip_temp_dir = tempfile.mktemp()
        extracted_dir = tempfile.mkdtemp()

        with open(zip_temp_dir, 'wb') as zip_temp:
            zip_temp.write(zip_file_bin)
        with ZipFile(zip_temp_dir) as zip_file:
            zip_file.extractall(extracted_dir)
        with open(os.path.join(extracted_dir, file_path),
                  'w+',
                  encoding='utf-8') as fp:
            fp.write(file_content)
        with ZipFile(zip_temp_dir, 'a') as zip_file:
            file_name = os.path.join(extracted_dir, file_path)
            zip_file.write(file_name, file_path)

        zip_file_id = uuid()

        with open(zip_temp_dir, 'rb') as zip_file:
            zip_file_bin = zip_file.read()
            resource.file_upload_bin(zip_file_id, zip_file_bin)
            if 'zip_file_id' in item:
                resource.file_delete_bin(
                    item['zip_file_id'])  # Remove previous zip file
            item['zip_file_id'] = zip_file_id  # Set new file's id
            success = resource.db_update_item(item['id'], item)
            body['success'] = success

        if 'requirements.txt' in file_path:
            requirements_zipfile_id = uuid()
            requirements_zipfile_bin = generate_requirements_zipfile(
                zip_file_bin)
            resource.file_upload_bin(requirements_zipfile_id,
                                     requirements_zipfile_bin)
            if 'requirements_zipfile_id' in item:
                resource.file_delete_bin(item['requirements_zipfile_id'])
            item['requirements_zipfile_id'] = requirements_zipfile_id

        return body