pulp-fosdem-2020-demo.py

from pulpcore.client.pulpcore import (
    ApiClient as CoreApiClient, ArtifactsApi, Configuration,
    TasksApi, Upload, UploadCommit, UploadsApi
)
from pulpcore.client.pulp_file import (
    ApiClient as FileApiClient, ContentFilesApi,
    DistributionsFileApi, FileFileDistribution,
    PublicationsFileApi, RemotesFileApi, FileFileRemote,
    RepositorySyncURL, FileFilePublication,
    FileFileRepository, RepositoriesFileApi,
    RepositoriesFileVersionsApi,
)
from pulpcore.client.pulp_container import (
    ApiClient as ContainerApiClient, DistributionsContainerApi, RepositoriesContainerApi,
    ContainerContainerRepository, RepositoriesContainerVersionsApi, ContainerContainerDistribution
)
from pprint import pprint
from time import sleep
import hashlib
import os
import pdb
from tempfile import NamedTemporaryFile


def monitor_task(task_href):
    """Polls the Task API until the task is in a completed state.

    Prints the task details and a success or failure message. Exits on failure.

    Args:
        task_href(str): The href of the task to monitor

    Returns:
        list[str]: List of hrefs that identify resource created by the task

    """
    completed = ['completed', 'failed', 'canceled']
    task = tasks.read(task_href)
    while task.state not in completed:
        sleep(2)
        task = tasks.read(task_href)
    pprint(task)
    if task.state == 'completed':
        print("The task was successful.")
        return task.created_resources
    else:
        print("The task did not finish successfully.")
        exit()

def upload_file_in_chunks(file_path):
    """Uploads a file using the Uploads API

    The file located at 'file_path' is uploaded in chunks of 200kb.

    Args:
        file_path (str): path to the file being uploaded to Pulp

    Returns:
        artifact object
    """
    size = os.stat(file_path).st_size
    chunk_size = 200000
    offset = 0
    sha256hasher = hashlib.new('sha256')

    upload = uploads.create(Upload(size=size))

    with open(file_path, 'rb') as full_file:
        while True:
            chunk = full_file.read(chunk_size)
            if not chunk:
                break
            actual_chunk_size = len(chunk)
            content_range = 'bytes {start}-{end}/{size}'.format(start=offset,
                                                                end=offset+actual_chunk_size-1,
                                                                size=size)
            with NamedTemporaryFile() as file_chunk:
                file_chunk.write(chunk)
                upload = uploads.update(upload_href=upload.pulp_href,
                                        file=file_chunk.name,
                                        content_range=content_range)
            offset += chunk_size
            sha256hasher.update(chunk)

        commit_response = uploads.commit(
            upload.pulp_href, UploadCommit(sha256=sha256hasher.hexdigest())
        )
        created_resources = monitor_task(commit_response.task)
        artifact = artifacts.read(created_resources[0])

    return artifact


# Configure HTTP basic authorization: basic
configuration = Configuration()
configuration.username = 'admin'
configuration.password = 'password'
configuration.safe_chars_for_path_param = '/'

core_client = CoreApiClient(configuration)
file_client = FileApiClient(configuration)
container_client = ContainerApiClient(configuration)

# Create api clients for all resource types
artifacts_api = ArtifactsApi(core_client)
filerepoversions = RepositoriesFileVersionsApi(file_client)
filecontent = ContentFilesApi(file_client)
file_distributions_api = DistributionsFileApi(file_client)
filepublications = PublicationsFileApi(file_client)
file_remotes_api = RemotesFileApi(file_client)
file_repos_api = RepositoriesFileApi(file_client)
container_repo_api = RepositoriesContainerApi(container_client)
containerrepoversions = RepositoriesContainerVersionsApi(container_client)
container_dist_api = DistributionsContainerApi(container_client)
tasks = TasksApi(core_client)
uploads = UploadsApi(core_client)

pdb.set_trace()

# Create a Repository
repository_data = FileFileRepository(name='foo25')
repository = file_repos_api.create(repository_data)
pprint(repository)

pdb.set_trace()

# Create a File Remote
remote_url = 'http://example.com:5000/some/repo/PULP_MANIFEST'
remote_data = FileFileRemote(name='repo-in-the-cloud', url=remote_url)
file_remote = file_remotes_api.create(remote_data)
pprint(file_remote)

# Sync a Repository
sync_data = RepositorySyncURL(remote=file_remote.pulp_href)
sync_response = file_repos_api.sync(repository.pulp_href, sync_data)

# Monitor the sync task
created_resources = monitor_task(sync_response.task)

repository_version_1 = filerepoversions.read(created_resources[0])
pprint(repository_version_1)

pdb.set_trace()

# Create a publication from the latest version of the repository
publish_data = FileFilePublication(repository=repository.pulp_href)
publish_response = filepublications.create(publish_data)

# Monitor the publish task
created_resources = monitor_task(publish_response.task)
publication_href = created_resources[0]

pdb.set_trace()

distribution_data = FileFileDistribution(
    name='baz', base_path='foo/dev', publication=publication_href
)
distribution = file_distributions_api.create(distribution_data)
pprint(distribution)

pdb.set_trace()

container_repo = ContainerContainerRepository(name='bar')
repository = container_repo_api.create(container_repo)

pdb.set_trace()

# Upload an artifact we want to use in the container
hello_world = artifacts_api.create(file='/home/vagrant/devel/FOSDEM2020/hello-world.txt')

pdb.set_trace()

artifacts = '{{"{}": "foo/bar/example.txt"}}'.format(hello_world.pulp_href)
build_response = container_repo_api.build_image(repository.pulp_href, containerfile='./Dockerfile', artifacts=artifacts)
created_resources = monitor_task(build_response.task)
repository_version = created_resources[0]
pprint(containerrepoversions.read(repository_version))

pdb.set_trace()

distribution_data = ContainerContainerDistribution(name='FOSDEM2020', base_path='fosdem/2020', repository=repository.pulp_href)
distribution = container_dist_api.create(distribution_data)