fpm-dockery 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: c935a1fef8fa2087d31346840b6485bc572ec539
+  data.tar.gz: 9d200efd489fd6d69d29ecdf16d15eed9ed9e929
+SHA512:
+  metadata.gz: 9ba023b1e3175338547cb678b8b7601d6d2fccb59c50fa942d7d01de325ca78a7d07b8d53aee03ac445edf3ee3cc1b427870a8300152d8c9a556eecab5518081
+  data.tar.gz: f6084650e84dc08246ada4911a3b1f22c2ac86e2ab869ae74474a75137212f5e5d244ddd3b3c400b302209548ce18e2b83f819a590bbfa5b9404e8940862944b

data/.gitignore

@@ -0,0 +1,10 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+/example_recipe/pkg

data/.ruby-gemset

@@ -0,0 +1 @@
+fpm-dockery

data/.ruby-version

@@ -0,0 +1 @@
+2.1.5

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in fpm-dockery.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 Andy Sykes
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,147 @@
+# fpm-dockery
+
+Build [fpm-cookery](https://github.com/forward3d/fpm-cookery) recipes with Docker!
+
+## What is this?
+
+This is a terribly-named wrapper around [fpm-cookery](https://github.com/forward3d/fpm-cookery) 
+that allows you to run fpm-cookery builds inside a container. I wrote this to allow me to run package builds 
+in development on my laptop in the same way that Jenkins runs them, and to allow easy building of packages 
+for a variety of Linux distributions.
+
+## Why would you use this?
+
+If you are building your own operating system packages, you should be running them in a clean
+environment every time. fpm-cookery is a superb tool for expressing the process of building and packaging
+using fpm, but it provides no real functionality for working in a clean environment.
+
+With the advent of [Docker](https://www.docker.com/), it is fast and easy to bring up an isolated 
+environment (a container) to perform the package building in. It also allows your CI server to perform 
+a very simple invocation to build packages (`fpm-dockery build recipe.rb ubuntu12.04`), and allows you 
+to run the same build on your development machine in the same way.
+
+If a build fails, you can easily re-run the container and be dropped into the state where the build failed.
+This makes it very easy to troubleshoot why a build is failing.
+
+## How does it work?
+
+`fpm-dockery` has the notion of 'builder' images. These are specially prepared Docker images that 
+contain enough tooling to get `fpm-cookery` working, along with `fpm-cookery` itself.
+
+You can see the Dockerfiles used to generate these images in the 
+[`docker` directory](https://github.com/andytinycat/fpm-dockery/tree/master/docker) of this
+repository.
+
+__NOTE: if you'd like to see more distributions supported, please contribute a Dockerfile in
+a pull request - it will be welcomed! I went with what I know and use, but Centos/Fedora support should
+be fairly trivial.__
+
+These 'builder' images launch `fpm-cook` with specifically-crafted arguments to ensure a clean
+build each time - and each build takes place in a new container created from the 'builder' image.
+
+The containers launch with two volumes attached - one volume is the directory containing the recipe,
+and the other volume is the output directory for the packages. The arguments supplied to `fpm-cook`
+ensure packages are placed in the correct location.
+
+## Limitations
+
+The following limitations are imposed on recipes you use with `fpm-dockery`:
+
+  * If a recipe includes external files, these files must be in the same directory
+    as the recipe file, or any number of subdirectories below where the recipe file is located.
+    This is because the directory containing the recipe is mounted inside the Docker container
+    when a build occurs, so files in this directory or lower can be referenced.
+  * Since we're using Docker, we can only run builds on Linux distributions.
+
+## Installation
+
+fpm-dockery is distributed as a Rubygem:
+
+`gem install fpm-dockery`
+
+Once you've installed it, you will have access to the `fpm-dockery` command line tool.
+
+## Usage
+
+`fpm-dockery` has command line documentation, accessible by supplying the `--help argument`:
+
+    $ bin/fpm-dockery --help
+    Usage:
+        fpm-dockery [OPTIONS] SUBCOMMAND [ARG] ...
+    
+    Parameters:
+        SUBCOMMAND                    subcommand
+        [ARG] ...                     subcommand arguments
+    
+    Subcommands:
+        create-builder-image          Build one of the fpm-dockery Docker 'builder' images
+        package                       Run fpm-cookery in a Docker container to produce a package
+        list-builders                 List available builders
+    
+    Options:
+        -h, --help                    print help
+
+### Building packages
+
+To create a package, run `fpm-dockery package`, which takes two required arguments and one
+optional argument:
+
+    fpm-dockery package PATH_TO_RECIPE BUILDER [PACKAGE_DIR]
+
+The builder is one of the supported builder images. If the builder image does not exist on the 
+system where Docker is running, it will be automatically created first. The packages will be
+created in `PATH_TO_RECIPE/pkg`.
+
+For example, to run the supplied example recipe (which builds Redis) on Ubuntu Precise (12.04 LTS), run:
+
+    fpm-dockery package example_recipe/recipe.rb ubuntu12.04
+
+If you'd like to override where packages are created, you can specify the optional third
+argument `PACKAGE_DIR`:
+
+    fpm-dockery package example_recipe/recipe.rb ubuntu12.04 /tmp/somedir
+
+
+### Viewing available builders
+
+To see the available builders, run:
+
+    fpm-dockery list-builders
+
+### Manually creating builder images
+
+If you'd like to run a builder image creation task manually, you can run:
+
+    fpm-dockery create-builder-image BUILDER
+
+For example, to build the Ubuntu Trusty (14.04 LTS) builder image, run:
+
+    fpm-dockery create-builder-image ubuntu14.04
+
+If you want to run this image creation without the Docker cache (perhaps your image is somehow
+messed up), run:
+
+    fpm-dockery create-builder-image --no-cache BUILDER
+
+For example, to run the Trusty build again with no cache:
+
+    fpm-dockery create-builder-image --no-cache ubuntu14.04
+
+## Contributing
+
+Pull requests are welcomed, especially for supporting new distributions. This project was a spike to replace
+some unpleasant homegrown scripts at [Forward3D](https://github.com/forward3d), so it's immature. Bugfixes and features welcomed.
+
+1. Fork it ( https://github.com/[my-github-username]/fpm-dockery/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request
+
+## Acknowledgements
+
+Thanks to [@bernd](https://github.com/bernd) for creating fpm-cookery, and [@sissel](https://github.com/jordansissel) 
+for creating FPM, without which life would be less pleasant.
+
+I also used the Redis example recipe from @bernd's repository and placed it in this repository so it can be used 
+for a quick proof-of-concept.

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+

data/bin/fpm-dockery

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+
+require 'bundler/setup'
+Bundler.require
+require 'fpm/dockery'
+
+FPM::Dockery::CLI.run

data/docker/Dockerfile.ubuntu12.04

@@ -0,0 +1,25 @@
+FROM ubuntu:12.04
+
+RUN apt-get update
+
+# Additional tooling
+RUN apt-get install -y git
+RUN apt-get install -y curl
+RUN apt-get install -y mercurial
+RUN apt-get install -y subversion
+
+# Build tools
+RUN apt-get install -y build-essential
+
+# Install Ruby from Brightbox's PPA
+RUN apt-get -y install python-software-properties
+RUN apt-add-repository ppa:brightbox/ruby-ng
+RUN apt-get update
+RUN apt-get -y install ruby2.1
+RUN apt-get -y install ruby2.1-dev
+
+# Install fpm-cookery
+RUN gem install fpm-cookery -v 0.27.0
+
+# Set an entry point to simplify command execution
+ENTRYPOINT ["/usr/local/bin/fpm-cook"]

data/docker/Dockerfile.ubuntu14.04

@@ -0,0 +1,25 @@
+FROM ubuntu:14.04
+
+RUN apt-get update
+
+# Additional tooling
+RUN apt-get install -y git
+RUN apt-get install -y curl
+RUN apt-get install -y mercurial
+RUN apt-get install -y subversion
+
+# Build tools
+RUN apt-get install -y build-essential
+
+# Install Ruby from Brightbox's PPA
+RUN apt-get -y install software-properties-common
+RUN apt-add-repository ppa:brightbox/ruby-ng
+RUN apt-get update
+RUN apt-get -y install ruby2.1
+RUN apt-get -y install ruby2.1-dev
+
+# Install fpm-cookery
+RUN gem install fpm-cookery -v 0.27.0
+
+# Set an entry point to simplify command execution
+ENTRYPOINT ["/usr/local/bin/fpm-cook"]

data/example_recipe/recipe.rb

@@ -0,0 +1,48 @@
+class Redis < FPM::Cookery::Recipe
+  homepage 'http://redis.io'
+
+  # Different source methods.
+  #
+  #source   'https://github.com/antirez/redis/trunk', :with => :svn
+  #source   'https://github.com/antirez/redis/trunk', :with => :svn, :revision => '2400'
+  #
+  #source   'https://github.com/antirez/redis', :with => :git, :tag => '2.4.2
+  #source   'https://github.com/antirez/redis', :with => :git, :branch => '2.4'
+  #source   'https://github.com/antirez/redis', :with => :git, :sha => '072a905'
+
+  source    'http://redis.googlecode.com/files/redis-2.4.2.tar.gz'
+  md5      'c4b0b5e4953a11a503cb54cf6b09670e'
+
+  name     'redis-server'
+  version  '2.4.2'
+#  revision '0' # => redis-server-2.2.5+fpm1
+
+  description 'An advanced key-value store.'
+
+  conflicts 'redis-server'
+
+  config_files '/etc/redis/redis.conf'
+
+  patches 'patches/test.patch'
+
+  def build
+    make
+
+    inline_replace 'redis.conf' do |s|
+      s.gsub! 'daemonize no', 'daemonize yes # non-default'
+    end
+  end
+
+  def install
+    # make :install, 'DESTDIR' => destdir
+
+    var('lib/redis').mkdir
+
+    %w(run log/redis).each {|p| var(p).mkdir }
+
+    bin.install ['src/redis-server', 'src/redis-cli']
+
+    etc('redis').install 'redis.conf'
+    etc('init.d').install workdir('redis-server.init.d') => 'redis-server'
+  end
+end

data/example_recipe/redis-server.init.d

@@ -0,0 +1,80 @@
+#! /bin/sh
+### BEGIN INIT INFO
+# Provides:		redis-server
+# Required-Start:	$syslog
+# Required-Stop:	$syslog
+# Should-Start:		$local_fs
+# Should-Stop:		$local_fs
+# Default-Start:	2 3 4 5
+# Default-Stop:		0 1 6
+# Short-Description:	redis-server - Persistent key-value db
+# Description:		redis-server - Persistent key-value db
+### END INIT INFO
+
+
+PATH=/usr/local/sbin:/usr/local/bin:/sbin:/bin:/usr/sbin:/usr/bin
+DAEMON=/usr/bin/redis-server
+DAEMON_ARGS=/etc/redis/redis.conf
+NAME=redis-server
+DESC=redis-server
+PIDFILE=/var/run/redis.pid
+
+test -x $DAEMON || exit 0
+test -x $DAEMONBOOTSTRAP || exit 0
+
+set -e
+
+case "$1" in
+  start)
+	echo -n "Starting $DESC: "
+	touch $PIDFILE
+	chown redis:redis $PIDFILE
+	chown redis:redis /var/log/redis
+	chown redis:redis /var/lib/redis
+	if start-stop-daemon --start --quiet --umask 007 --pidfile $PIDFILE --chuid redis:redis --exec $DAEMON -- $DAEMON_ARGS
+	then
+		echo "$NAME."
+	else
+		echo "failed"
+	fi
+	;;
+  stop)
+	echo -n "Stopping $DESC: "
+	if start-stop-daemon --stop --retry 10 --quiet --oknodo --pidfile $PIDFILE --exec $DAEMON
+	then
+		echo "$NAME."
+	else
+		echo "failed"
+	fi
+	rm -f $PIDFILE
+	;;
+
+  restart|force-reload)
+	${0} stop
+	${0} start
+	;;
+  status)
+        if [ -f $PIDFILE ]
+        then
+                PID=`cat $PIDFILE`
+                echo -n "Redis (pid: $PID): "
+                if ps aux | grep $PID > /dev/null
+                then
+                        echo "running"
+                        exit 0
+                else
+                        echo "failed"
+                        exit 3
+                fi
+        else
+                echo "Redis not running"
+                exit 3
+        fi
+        ;;
+  *)
+	echo "Usage: /etc/init.d/$NAME {start|stop|restart|force-reload}" >&2
+	exit 1
+	;;
+esac
+
+exit 0

data/fpm-dockery.gemspec

@@ -0,0 +1,26 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'fpm/dockery/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "fpm-dockery"
+  spec.version       = Fpm::Dockery::VERSION
+  spec.authors       = ["Andy Sykes"]
+  spec.email         = ["github@tinycat.co.uk"]
+
+  spec.summary       = %q{Build fpm-cookery recipes with Docker!}
+  spec.description   = %q{Use Docker to produce clean builds of fpm-cookery recipes by building in containers}
+  spec.homepage      = "https://github.com/andytinycat/fpm-dockery"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_runtime_dependency "clamp", "~> 0.6.4"
+
+  spec.add_development_dependency "bundler", "~> 1.8"
+  spec.add_development_dependency "rake", "~> 10.0"
+end

data/lib/fpm/dockery.rb

@@ -0,0 +1,16 @@
+require "clamp"
+require "logger"
+require "open3"
+
+require "fpm/dockery/version"
+require "fpm/dockery/logging"
+require "fpm/dockery/utils"
+require "fpm/dockery/cli"
+
+module FPM
+  module Dockery
+    def self.root
+      File.expand_path("../../../", __FILE__)
+    end
+  end
+end

data/lib/fpm/dockery/cli.rb

@@ -0,0 +1,108 @@
+require 'optparse'
+
+module FPM
+  module Dockery
+    class CLI < Clamp::Command
+      
+      class BaseCommand < Clamp::Command
+        include Logging
+        include Utils
+        
+        def valid_builders
+          Dir.glob("#{FPM::Dockery.root}/docker/Dockerfile.*").map {|f| File.basename(f.gsub('Dockerfile.', ''))}
+        end
+        
+        def validate_builder!
+          unless valid_builders.include?(builder)
+            fatal "Image type must be one of: #{valid_builders.join(', ')}"
+            exit 1
+          end
+        end
+        
+        def create_builder_if_required
+          image_check = Subprocess.run("docker images | awk '{print $1}' | grep fpm-dockery/#{builder}")
+          unless image_check.exitstatus == 0
+            warn "The builder image '#{builder}' does not exist; running the image creation for you"
+            create_builder(false)
+          end
+        end
+        
+        def create_builder(no_cache)
+          validate_builder!
+          cache_option = no_cache ? '--no-cache=true' : ''
+          exit_status = Subprocess.run("docker build #{cache_option} -f #{FPM::Dockery.root}/docker/Dockerfile.#{builder} -t fpm-dockery/#{builder} #{FPM::Dockery.root}")
+          if exit_status.exitstatus == 0
+            info "Build complete"
+          else
+            info "Build process exited with a non-zero exit code"
+            exit exit_status.exitstatus
+          end
+        end
+        
+      end
+      
+      class ListBuildersCommand < BaseCommand
+        def execute
+          puts valid_builders.join("\n")
+        end
+      end
+      
+      class CreateBuilderImage < BaseCommand
+        parameter "BUILDER", "Type of builder image to build"
+        option "--no-cache", :flag, "Build without cache"
+      
+        def execute
+          create_builder(no_cache?)
+        end
+      end
+    
+      class PackageCommand < BaseCommand
+        parameter "RECIPE", "fpm-cookery recipe to build"
+        parameter "BUILDER", "Builder to use"
+        parameter "[PACKAGE_DIR]", "Where to place the packages created by the build (defaults to /pkg in same dir as recipe)"
+        
+        def execute
+          recipe_path = File.expand_path(recipe)
+          dir_to_mount = File.dirname(recipe_path)
+          name_of_recipe = File.basename(recipe_path)
+          
+          validate_builder!
+          create_builder_if_required
+          
+          extra_command = ''
+          pkg_dir = "/recipe/pkg"
+          
+          if package_dir
+            extra_command = "-v #{File.expand_path(package_dir)}:/output"
+            pkg_dir = "/output"
+          end
+            
+          command = <<eos
+docker run \
+-v #{dir_to_mount}:/recipe \
+#{extra_command} \
+fpm-dockery/ubuntu \
+--tmp-root /tmp/tmproot \
+--pkg-dir #{pkg_dir} \
+--cache-dir /tmp/cache \
+package \
+/recipe/#{name_of_recipe}
+eos
+          exit_status = Subprocess.run(command)
+          if exit_status.exitstatus == 0
+            info "Packaging complete"
+          else
+            info "Packaging process exited with a non-zero exit code"
+            exit exit_status.exitstatus
+          end
+        end
+        
+      end
+      
+      subcommand "create-builder-image", "Build one of the fpm-dockery Docker 'builder' images", CreateBuilderImage      
+      subcommand "package", "Run fpm-cookery in a Docker container to produce a package", PackageCommand
+      subcommand "list-builders", "List available builders", ListBuildersCommand
+      
+    end
+  end
+end

data/lib/fpm/dockery/logging.rb

@@ -0,0 +1,24 @@
+module FPM
+  module Dockery
+    module Logging
+      
+      @@logger = Logger.new(STDOUT)
+      @@logger.formatter = proc do |severity, datetime, progname, msg|
+        "[#{severity}] #{msg}\n"
+      end
+      
+      def info(msg)
+        @@logger.info(msg)
+      end
+      
+      def warn(msg)
+        @@logger.warn(msg)
+      end
+      
+      def fatal(msg)
+        @@logger.fatal(msg)
+      end
+      
+    end
+  end
+end

data/lib/fpm/dockery/utils.rb

@@ -0,0 +1,36 @@
+module FPM
+  module Dockery
+    module Utils
+      
+      # A moderately decent way of dealing with running commands
+      # and coping with stdout/stderr
+      class Subprocess
+        extend Logging
+        def self.run(cmd, &block)
+          info "Running command '#{cmd}'"
+          log_command = "#{cmd.split(' ')[0]}"
+          # see: http://stackoverflow.com/a/1162850/83386
+          Open3.popen3(cmd) do |stdin, stdout, stderr, thread|
+            # read each stream from a new thread
+            { :out => stdout, :err => stderr }.each do |key, stream|
+              Thread.new do
+                until (line = stream.gets).nil? do
+                  # yield the block depending on the stream
+                  if key == :out
+                    info("[#{log_command}] [stdout] #{line.chomp}") unless line.nil?
+                  else
+                    info("[#{log_command}] [stderr] #{line.chomp}") unless line.nil?
+                  end
+                end
+              end
+            end
+    
+            thread.join # don't exit until the external process is done
+            return thread.value
+          end
+        end
+      end
+      
+    end
+  end
+end

data/lib/fpm/dockery/version.rb

@@ -0,0 +1,5 @@
+module Fpm
+  module Dockery
+    VERSION = "0.1.0"
+  end
+end

metadata

@@ -0,0 +1,105 @@
+--- !ruby/object:Gem::Specification
+name: fpm-dockery
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Andy Sykes
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2015-04-12 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: clamp
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.6.4
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.6.4
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.8'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.8'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+description: Use Docker to produce clean builds of fpm-cookery recipes by building
+  in containers
+email:
+- github@tinycat.co.uk
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".ruby-gemset"
+- ".ruby-version"
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- bin/fpm-dockery
+- docker/Dockerfile.ubuntu12.04
+- docker/Dockerfile.ubuntu14.04
+- example_recipe/recipe.rb
+- example_recipe/redis-server.init.d
+- fpm-dockery.gemspec
+- lib/fpm/dockery.rb
+- lib/fpm/dockery/cli.rb
+- lib/fpm/dockery/logging.rb
+- lib/fpm/dockery/utils.rb
+- lib/fpm/dockery/version.rb
+homepage: https://github.com/andytinycat/fpm-dockery
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.3
+signing_key: 
+specification_version: 4
+summary: Build fpm-cookery recipes with Docker!
+test_files: []