How to: Upload (Advanced)

# Our perssitence layer for queuing uploads. Might use SQLite or another
# database under the hood
C2C_UPLOAD_STORE = NewC2CUploadStore()

# The http session that will handle TCP 
# connection pooling for us.
HTTP_SESSION = http.Session()

def take_picture():
    """Snaps a picture for the user."""

    image = MY_DEVICE.capture()
    file_path = MY_DEVICE.write_image(image)

    # Add a new file to the store.
    C2C_UPLOAD_STORE.add_file(file_path)

def task_register_assets():
    """
    Pulls snapped pictures from the FILE_QUEUE, registers
    with Frame.io, and adds the chunks to the CHUNK_QUEUE.
    """
    while True:
        # Get the latest file path from our store.
        file_record = C2C_UPLOAD_STORE.get_file()

        try:
            asset = c2c.crete_asset_for_file(HTTP_SESSION, file_record)
            chunk_size = c2c.calculate_chunk_size(asset, file_record)

            chunk_start = 0
            for chunk_url in asset.upload_urls:
                message = {
                    "file_path": file_record,
                    "chunk_url": chunk_url,
                    "chunk_start": chunk_start,
                    "chunk_size": chunk_size,
                }

                # Put the chunk job in the store.
                C2C_UPLOAD_STORE.new_chunk(message)
                chunk_start += chunk_size
        except BaseException as error:
            # Tell the store we ran into an error so we can retry
            # later if needed.
            C2C_UPLOAD_STORE.file_asset_create_error(file_record, error)
        else:
            # Tell the store we successfully created our asset.
            C2C_UPLOAD_STORE.file_asset_created(file_record)

def task_upload_chunk():
    """Takes a chunks and uploads them."""

    while True:
        # Get the next chunk from our store. Our store should
        # check this chunk out so it will not be fetched by
        # other uploader tasks.
        chunk_record = C2C_UPLOAD_STORE.get_chunk()

        try:
            c2c.upload_chunk(HTTP_SESSION, chunk_record)
        except BaseException as error:
            # If we get an error, mark it in the store so we
            # can try again later.
            C2C_UPLOAD_STORE.chunk_error(chunk_record, error)
        else:
            # Mark success of the chunk.
            C2C_UPLOAD_STORE.chunk_success(chunk_record)

def launch_upload_tasks():
    """Lauches our Frame.io upload tasks."""
    # Create a list to hold all of our tasks.
    tasks = list()

    # Create one task for registering assets.
    asset_task = run_task_in_thread(task_register_assets)
    tasks.append(asset_task)

    # Create 2 tasks per CPU core for uploading chunks.
    for _ in range(0, GET_CPU_COUNT() * 2):
        chunk_task = run_task_in_thread(task_upload_chunk)
        tasks.append(chunk_task)

    # Run these tasks until shutdown
    run_forever(tasks)