Metadata-Version: 1.1
Name: fbad
Version: 0.1.2
Summary: build tools for docker images
Home-page: https://github.com/bennr01/fbad/
Author: bennr01
Author-email: benjamin99.vogt@web.de
License: MIT
Description: # FBAD
        FBAD is a commandline tool for projects requiring multiple docker images.
        
        # Features
        - easily build projects with multiple docker images
        - build on remote server
        - automatically push build images to registry
        - select a subset of images to build
        - build images in parallel on multiple buildservers
        - you can also build all images on each buildserver (useful for different os architectures)
        - run command before each image build (useful for generating dockerfiles before the build)
        - automatically format tags (e.g. `myproject-{arch}` -> `myproject-x86`)
        - show build output live
        - ...
        
        # Recommended directory structure
        
        ```
        myproject/
            imagea/
                DOCKERFILE
                ...
            imageb/
                DOCKERFILE
                ...
            ...
            project.py
        ```
        
        # Example `project.py`
        
        ```python
        """example fbad build file"""
        from fbad import Project, Image
        
        
        # the project contains all project and image data
        project = Project(
        
            # name of the project
            name="Project",
        
            # list of images of the project
            images=[
                # most simple form
                # build the dockerfile in 'cachserver/'
                # use 'cachserver/Dockerfile' as dockerfile
                # build cwd is 'cachserver/'
                # name and tag are 'cachserver'
                Image(
                    path="cacheserver/",
                    ),
        
                # build image from the directory which contains 'project.py'
                # everything like above, but cwd is different
                # this is useful if you have shared files, like a package for common functionality
                # please note that all files being contained in the buildpath will be send to the buildserver.
                Image(
                    path="webserver/",
                    buildpath="",
                    ),
        
                # build image with auto-formated tag and auto-generated dockerfile
                # the tag will be formated on the buildserver (e.g. 'worker-x86')
                # the dockerfile will also be generated on the buildserver
                # this is useful for building architecture specific images or
                # images with architecture-specific dependencies
                # this example also uses a custom buildpath
                Image(
                    path="worker/",
                    tag="worker-{arch}",
                    buildpath="",
                    preexec_command=["/usr/bin/python", "worker/generate_dockerfile.py"],
                    ),
        
                # build image with a dockerfile having a different name.
                # dockerfile will be 'db/dbdockerfile.txt'
                Image(
                    path="db/",
                    dockerfile="dbdockerfile.txt",
                    ),
                ],
            )
        
        
        if __name__ == "__main__":
            # run the cli
            project.main()
        
        ```
        
        # Buildserver
        A buildserver is available using the `fbad-server` command.
        You can also access import the buildserver as `fbad.server.FBADServerFactory`.
        If no custom buildserver is specified when building a project, another buildserver is temporarly started.
        
        # Installation
        **Requirements**
        FBAD requires python2 (most implementations should work) and twisted.
        The buildserver also requires docker to be installed.
        
        **Install via pip**
        1. `pip install fbad`
        2. Done
        
        **Install from source**
        1. `git clone https://github.com/bennr01/fbad.git`
        2. `cd fbad`
        3. `python setup.py install` (`sudo` may be required, depending on your python configuration)
        4. Done.
        
Keywords: docker build tools
Platform: UNKNOWN
Classifier: License :: OSI Approved :: MIT License
Classifier: Topic :: Software Development :: Build Tools
Classifier: Programming Language :: Python
Classifier: Development Status :: 3 - Alpha
Classifier: Programming Language :: Python :: 2.6
Classifier: Programming Language :: Python :: 2.7
