rackspace-scaling 0.0.1

data/.gitignore

@@ -0,0 +1,19 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+test.rb
+.idea

data/.rvmrc

@@ -0,0 +1 @@
+rvm use 1.9.3-p327@rackspace-scaling --create

data/Gemfile

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

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Mike Emery
+
+MIT License
+
+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,78 @@
+# Rackspace::Scaling
+
+This gem aims to provide a relatively simple library to increase your number of servers in a rackspace cloud and, optionally, attach those servers to a load balancer.  This gem is pretty low level in relation to the API, and doesn't abstract away much.
+
+Detailed information about the API can be found  here:
+
+http://docs.rackspace.com/servers/api/v2/cs-devguide/content/ch_api_operations.html
+http://docs.rackspace.com/loadbalancers/api/v1.0/clb-devguide/content/API_Operations-d1e1354.html
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'rackspace-scaling'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install rackspace-scaling
+
+## Usage
+
+### Api
+
+The very first thing you need to do is get an authentication token.
+
+    auth = Rackspace::Scaling::Authentication.new('account_name', 'api_key')
+
+You can then perform operations for servers or load balancers.
+
+#### Load Balancers
+
+    lb = Rackspace::Scaling::LoadBalancerOperation.new(auth, 'DFW')
+
+    #list all load balancers
+    puts lb.list
+
+    #list all nodes attached to a load balancer
+    puts lb.nodes(12345)
+
+    #Add a node to a load balancer, defaults to port 80, can be overriden with the :port option
+    puts lb.add_node(:load_balancer_id => 12345, :node_ip => 'internal or external ip')
+
+    #remove a node
+    puts lb.remove_node(:load_balancer_id => 12345, :node_id => 67890)
+    
+#### Servers
+    srv = Rackspace::Scaling::ServerOperation.new(auth, 'DFW')
+
+    # lists all the available images you can create servers with
+    srv.list_images
+
+    #list flavours (sizes) of machines you can spin up
+    srv.list_flavors
+
+    #get the status for a specific instance
+    srv.status('server guid')
+
+    #create a new server, required parameters are :image_id, :flavor_id, and :name
+    puts = srv.create(:flavor_id => '2', :image_id => 'guid', :name => 'fooserver')
+
+    #destroy a server
+    puts srv.destroy('server-guid')
+
+### Command-LIne
+
+Still in progress
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Added some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,2 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"

data/bin/rackspace_scale_down

@@ -0,0 +1,114 @@
+#!/usr/bin/env ruby
+
+require 'optparse'
+require 'rackspace-scaling'
+require 'ostruct'
+
+class ScaleDown
+  include Rackspace::Scaling::CmdUtil
+  attr_reader :options
+
+  def initialize(args)
+    @options = OpenStruct.new
+    @options.n_decrease = 1
+    @options.region = 'DFW'
+    parse_options(args)
+  end
+  
+  def parse_options(args)
+    parser = OptionParser.new do |opts|
+      opts.banner = "Usage: --login LOGIN --api-key API_KEY rackspace_scale_down -l LOAD_BALANCER_ID [-n INSTANCES_TO_CREATE] [-s SCALE_FACTOR]"
+      
+      opts.on('--login LOGIN', 'Your rackspace login.') { |login|
+        options.login = login
+      }
+
+      opts.on('--api-key API_KEY', 'Your rackspace API key.') { |api_key|
+        options.api_key = api_key
+      }
+      
+      opts.on('-r REGION', 'Three letter acronym representing the data center.  Defaults to DFW.')
+
+      opts.on('-l LOAD_BALANCER_ID', OptionParser::DecimalInteger, 'Numeric id of the load balancer.') { |lb_id|
+        options.load_balancer_id = lb_id
+      }
+      
+      opts.on('-s SCALE_FACTOR', OptionParser::DecimalInteger, 'Decrease the number of instances on the load balancer by 1/s times, rounded down.') { |scale|
+        options.scale = scale
+      }
+
+      opts.on('-n INSTANCES_TO_DESTROY', OptionParser::DecimalInteger, 'Increase the number of instances by n') { |n_decrease|
+        options.n_decrease = n_decrease
+      }
+
+      opts.on_tail("-h", "--help", "Show this message") do
+        puts parser
+        exit
+      end
+    end
+    
+    parser.parse!(args)
+
+    if (options.login.nil? || options.api_key.nil? || options.load_balancer_id.nil?)
+      puts parser
+      exit(1)
+    end
+
+    if(options.n_decrease && options.scale)
+      puts "You can't specify both a fixed decrease in instances and a scale factor"
+      puts parser
+      exit(1)
+    end
+  end
+  
+  def run
+    print "Getting api token..."
+    auth = Rackspace::Scaling::Authentication.new(options.login, options.api_key)
+    lb = Rackspace::Scaling::LoadBalancerOperation.new(auth, options.region)
+    srv = Rackspace::Scaling::ServerOperation.new(auth, options.region)
+    puts "done"
+
+    print "Getting list of nodes attached to load balancer..."
+    nodes = lb.nodes(options.load_balancer_id)
+    puts "done"
+    
+    print("Listing servers...")
+    servers = srv.list_servers(:detail => true)
+    puts("done")
+    
+    if(options.scale)
+      options.n_decrease = (nodes.size / options.scale).floor
+      puts "You only have #{nodes.size} nodes available, scaling down by #{options.n_decrease} instead"
+    end
+    
+    options.n_decrease = [nodes.size - 1, options.n_decrease].min
+    
+    puts "Scaling down by #{options.n_decrease}"
+    
+    nodes.sort!{ |a, b| a['condition'] <=> b['condition'] } # take disabled nodes first
+    removed_nodes = 0
+    
+    nodes.each do |node|
+      
+      if(removed_nodes >= options.n_decrease)
+         break
+       end
+      
+      instance_ip = node['address']
+      server = find_instance_by_ip(instance_ip, servers)
+      
+      print("Removing node #{node['address']} from load balancer...")
+      lb.remove_node(:load_balancer_id => options.load_balancer_id, :node_id => node['id'])
+      puts "done"
+      
+      print("Destroying server for ip #{node['address']}...")
+      result = srv.destroy(server['id'])
+      puts(result)
+      
+      removed_nodes += 1
+    end
+  end
+end
+
+scale_down = ScaleDown.new(ARGV)
+scale_down.run

data/bin/rackspace_scale_up

@@ -0,0 +1,141 @@
+#!/usr/bin/env ruby
+
+require 'optparse'
+require 'rackspace-scaling'
+require 'ostruct'
+
+class ScaleUp
+  include Rackspace::Scaling::CmdUtil
+  attr_reader :options
+
+  def initialize(args)
+    @options = OpenStruct.new
+    @options.n_increase = 1
+    @options.region = 'DFW'
+    parse_options(args)
+  end
+
+  def parse_options(args)
+
+    parser = OptionParser.new do |opts|
+      opts.banner = "Usage: --login LOGIN --api-key API_KEY rackspace_scale_up -l LOAD_BALANCER_ID -i IMAGE_NAME [-n INSTANCES_TO_CREATE] [-s SCALE_FACTOR]"
+
+      opts.on('--login LOGIN', 'Your rackspace login.') { |login|
+        options.login = login
+      }
+
+      opts.on('--api-key API_KEY', 'Your rackspace API key.') { |api_key|
+        options.api_key = api_key
+      }
+      
+      opts.on('-r REGION', 'Three letter acronym representing the data center.  Defaults to DFW.')
+
+      opts.on('-l LOAD_BALANCER_ID', OptionParser::DecimalInteger, 'Numeric id of the load balancer.') { |lb_id|
+        options.load_balancer_id = lb_id
+      }
+      
+      opts.on('-i IMAGE_NAME', 'Name of the image you want to use to scale') { |image_name|
+        options.image_name = image_name
+      }
+
+      opts.on('-s SCALE_FACTOR', OptionParser::DecimalInteger, 'Increase the number of instances on the load balancer by s times.') { |scale|
+        options.scale = scale
+      }
+
+      opts.on('-n INSTANCES_TO_CREATE', OptionParser::DecimalInteger, 'Increase the number of instances by n') { |n_increase|
+        options.n_increase = n_increase
+      }
+
+      opts.on_tail("-h", "--help", "Show this message") do
+        puts parser
+        exit
+      end
+    end
+
+    parser.parse!(args)
+
+    if (options.login.nil? || options.api_key.nil? || options.load_balancer_id.nil? || options.image_name.nil?)
+      puts parser
+      exit(1)
+    end
+
+    if(options.n_increase && options.scale)
+      puts "You can't specify both a fixed increase in instances and a scale factor"
+      puts parser
+      exit(1)
+    end
+  end
+
+  def run
+    print "Getting api token..."
+    auth = Rackspace::Scaling::Authentication.new(options.login, options.api_key)
+    lb = Rackspace::Scaling::LoadBalancerOperation.new(auth, options.region)
+    srv = Rackspace::Scaling::ServerOperation.new(auth, options.region)
+    puts "done"
+    
+    nodes = lb.nodes(options.load_balancer_id)
+    
+    instance_ip = nodes.first['address']
+    
+    print("Listing servers...")
+    servers = srv.list_servers(:detail => true)
+    puts("done")
+    
+    print("Retrieving server for IP #{instance_ip}...")
+    server = find_instance_by_ip(instance_ip, servers)
+    puts("done")
+    
+    print("Listing images...")
+    images = srv.list_images(:detail => true)
+    puts("done")
+    
+    print("Finding image for name #{options.image_name}...")
+    image = find_image_by_name(options.image_name, images)
+    puts("done")
+    
+    if(options.scale)
+      options.n_increase = nodes * options.scale
+    end
+    
+    puts "Increasing number of instances by #{options.n_increase}"
+    
+    created_servers = []
+    options.n_increase.times do |i|
+      print("Creating server...")
+      new_server = srv.create(:name => "#{image['name']}", :image_id => image['id'], :flavor_id => server['flavor']['id'])
+      puts("done")
+      
+      if(new_server)
+        created_servers << new_server['id']
+      end
+    end
+    
+    puts "Created #{created_servers.size} new servers"
+    
+    while(created_servers.size > 0)
+      created_servers.dup.each do |server_id|
+        new_server_details = srv.status(server_id)
+        
+        if(new_server_details['addresses'].any? && new_server_details['status'] == 'ACTIVE')
+          private_ip = new_server_details['addresses']['private'].first['addr']
+          puts "Server #{server_id} has ip #{private_ip}"
+          
+          print("Adding server to load balancer...")
+          lb.add_node(:load_balancer_id => options.load_balancer_id, :node_ip => private_ip)
+          puts("done")
+          created_servers.delete(server_id)
+        else
+          puts "Server #{server_id} is not ready to be put into rotation (ip: #{new_server_details['addresses'].any?}, status: #{new_server_details['status']}), waiting."
+        end
+      end
+      sleep(5) if created_servers.any?
+    end
+    
+    puts 'Scaling complete'
+  end
+  
+
+end
+
+s = ScaleUp.new(ARGV)
+s.run

data/lib/rackspace-scaling.rb

@@ -0,0 +1,14 @@
+require 'typhoeus'
+require 'json'
+require 'net/http'
+require 'rackspace-scaling/version'
+require 'rackspace-scaling/authentication'
+require 'rackspace-scaling/load_balancer_operation'
+require 'rackspace-scaling/server_operation'
+require 'rackspace-scaling/cmd_util'
+
+module Rackspace
+  module Scaling
+    # Your code goes here...
+  end
+end

data/lib/rackspace-scaling/authentication.rb

@@ -0,0 +1,56 @@
+
+module Rackspace
+  module Scaling
+    class Authentication
+      
+      attr_reader :user_name
+      
+      ENDPOINT = 'https://identity.api.rackspacecloud.com/v2.0/tokens'
+      
+      def initialize(username, api_key)
+        @user_name = username
+        @payload = {
+          :auth => {
+            "RAX-KSKEY:apiKeyCredentials" => {
+              'username' => username,
+              'apiKey' => api_key
+            }
+          }
+        }
+      end
+      
+      def authenticate
+        @authenticated ||= begin
+          resp = Typhoeus::Request.post(ENDPOINT, :body => @payload.to_json, :headers => {'Content-Type' => 'application/json'})
+          parsed_response = JSON.parse(resp.body)
+          @token = parsed_response['access']['token']['id']
+          @service_catalog = {}
+          
+          parsed_response['access']['serviceCatalog'].each do |entry|
+            @service_catalog[entry['name']] = {
+              'type' => entry['type'],
+              'endpoints' => {}
+            }
+            
+            entry['endpoints'].each do |endpoint|
+              @service_catalog[entry['name']]['endpoints'][endpoint['region']] = endpoint
+            end
+          end
+          
+          true
+        end
+      end
+      
+      def endpoints
+        authenticate
+        @service_catalog
+      end
+      
+      def token
+        authenticate
+        @token
+      end
+      
+    end # /Authentication
+  end
+end

data/lib/rackspace-scaling/cmd_util.rb

@@ -0,0 +1,35 @@
+module Rackspace
+  module Scaling
+    module CmdUtil
+      
+      def find_instance_by_ip(target_ip, server_list)
+        server_list.each do |server|
+          server['addresses'].each do |k, v|
+            v.each do |ip|
+              if(ip['addr'] == target_ip)
+                return server
+              end
+            end
+          end
+        end
+
+        nil
+      end
+      
+      def find_image_by_name(name, images)
+        images.sort!{ |a, b| b['created'] <=> a['created']}
+        found_image = nil
+
+        images.each do |image|
+          if(image['name'] == name)
+            found_image = image
+            break
+          end
+        end
+        
+        found_image
+      end
+      
+    end
+  end
+end

data/lib/rackspace-scaling/load_balancer_operation.rb

@@ -0,0 +1,51 @@
+module Rackspace
+  module Scaling
+    class LoadBalancerOperation
+      def initialize(auth, region = 'DFW')
+        @auth = auth
+        @endpoint = @auth.endpoints['cloudLoadBalancers']['endpoints'][region]['publicURL']+"/loadbalancers"
+      end
+
+      def list
+        @list ||= begin
+          resp = Typhoeus::Request.get(@endpoint, :headers => { 'X-Auth-Token' => @auth.token, 'Accept' => 'application/json'})
+          parsed_response = JSON.parse(resp.body)['loadBalancers']
+        end
+      end
+      
+      def nodes(load_balancer_id)
+        path = "#{@endpoint}/#{load_balancer_id}/nodes"
+        @images ||= begin
+          resp = Typhoeus::Request.get(path, :headers => { 'X-Auth-Token' => @auth.token, 'Accept' => 'application/json'})
+          parsed_response = JSON.parse(resp.body)['nodes']
+        end
+      end
+      
+      def add_node(options = {})
+        load_balancer_id = options[:load_balancer_id]
+        body = {
+          :nodes => [
+            {
+              :address => options[:node_ip],
+              :port => (options[:port] || 80),
+              :condition => (options[:condition] || 'ENABLED'),
+              :type => (options[:type] || 'PRIMARY')
+            }
+          ]
+        }
+        path = "#{@endpoint}/#{load_balancer_id}/nodes"
+        resp = Typhoeus::Request.post(path, :headers => { 'X-Auth-Token' => @auth.token, 'Accept' => 'application/json', 'Content-Type' => 'application/json'}, :body => body.to_json)
+        JSON.parse(resp.body)['nodes']
+      end
+      
+      def remove_node(options = {})
+        load_balancer_id = options[:load_balancer_id]
+        node_id = options[:node_id]
+        path = "#{@endpoint}/#{load_balancer_id}/nodes/#{node_id}"
+        resp = Typhoeus::Request.delete(path, :headers => { 'X-Auth-Token' => @auth.token, 'Accept' => 'application/json'})
+        resp.success?
+      end
+      
+    end # /LoadBalancerOperation
+  end
+end

data/lib/rackspace-scaling/server_operation.rb

@@ -0,0 +1,68 @@
+module Rackspace
+  module Scaling
+    class ServerOperation
+      def initialize(auth, region = 'DFW')
+        @auth = auth
+        @server_endpoint = @auth.endpoints['cloudServersOpenStack']['endpoints'][region]['publicURL']+"/servers"
+        @flavor_endpoint = @auth.endpoints['cloudServersOpenStack']['endpoints'][region]['publicURL']+"/flavors"
+        @image_endpoint = @auth.endpoints['cloudServersOpenStack']['endpoints'][region]['publicURL']+"/images"
+      end
+      
+      def list_images(options = {})
+        url = "#{@image_endpoint}"
+        if(options[:detail])
+          url = "#{url}/detail"
+        end
+        
+        @image_list ||= begin
+          resp = Typhoeus::Request.get(url, :headers => { 'X-Auth-Token' => @auth.token, 'Accept' => 'application/json'})
+          parsed_response = JSON.parse(resp.body)['images']
+        end
+      end
+      
+      def list_flavors
+        @flavor_list ||= begin
+          resp = Typhoeus::Request.get(@flavor_endpoint, :headers => { 'X-Auth-Token' => @auth.token, 'Accept' => 'application/json'})
+          parsed_response = JSON.parse(resp.body)['flavors']
+        end
+      end
+      
+      def status(server_id)
+        url = "#{@server_endpoint}/#{server_id}"
+        resp = Typhoeus::Request.get(url, :headers => { 'X-Auth-Token' => @auth.token, 'Accept' => 'application/json'})
+        JSON.parse(resp.body)['server']
+      end
+      
+      def create(options = {})
+        create_options = {
+          :server => {
+            'name' => options[:name],
+            'imageRef' => options[:image_id],
+            'flavorRef' => options[:flavor_id] 
+          }
+        }
+        resp = Typhoeus::Request.post(@server_endpoint, :headers => { 'X-Auth-Token' => @auth.token, 'Accept' => 'application/json', 'Content-Type' => 'application/json'}, :body => create_options.to_json)
+        parsed_response = JSON.parse(resp.body)['server']
+      end
+      
+      def destroy(guid)
+        server_url = "#{@server_endpoint}/#{guid}"
+        resp = Typhoeus::Request.delete(server_url, :headers => { 'X-Auth-Token' => @auth.token, 'Accept' => 'application/json'})
+        return resp.success?
+      end
+      
+      def list_servers(options = {})
+        url = "#{@server_endpoint}"
+        
+        if(options[:detail])
+          url += '/detail'
+        end
+        
+        @server_list ||= begin
+          resp = Typhoeus::Request.get(url, :headers => { 'X-Auth-Token' => @auth.token, 'Accept' => 'application/json'})
+          parsed_response = JSON.parse(resp.body)['servers']
+        end
+      end
+    end # /ServerOperation
+  end
+end

data/lib/rackspace-scaling/version.rb

@@ -0,0 +1,5 @@
+module Rackspace
+  module Scaling
+    VERSION = "0.0.1"
+  end
+end

data/rackspace-scaling.gemspec

@@ -0,0 +1,19 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/rackspace-scaling/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Mike Emery"]
+  gem.email         = ["philodoxx@gmail.com"]
+  gem.description   = %q{Gem that allows you to scale up or scale down the number of machines you ahve running in the rackspace cloud.}
+  gem.summary       = %q{Gem that lets you scale the number of rackspace instances you have.}
+  gem.homepage      = ""
+
+  gem.files         = `git ls-files`.split($\)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.name          = "rackspace-scaling"
+  gem.require_paths = ["lib"]
+  gem.version       = Rackspace::Scaling::VERSION
+  gem.add_runtime_dependency 'typhoeus', '~> 0.4.2'
+  gem.add_runtime_dependency 'json'
+end

metadata

@@ -0,0 +1,95 @@
+--- !ruby/object:Gem::Specification
+name: rackspace-scaling
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Mike Emery
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-01-22 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: typhoeus
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.4.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.4.2
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Gem that allows you to scale up or scale down the number of machines
+  you ahve running in the rackspace cloud.
+email:
+- philodoxx@gmail.com
+executables:
+- rackspace_scale_down
+- rackspace_scale_up
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rvmrc
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- bin/rackspace_scale_down
+- bin/rackspace_scale_up
+- lib/rackspace-scaling.rb
+- lib/rackspace-scaling/authentication.rb
+- lib/rackspace-scaling/cmd_util.rb
+- lib/rackspace-scaling/load_balancer_operation.rb
+- lib/rackspace-scaling/server_operation.rb
+- lib/rackspace-scaling/version.rb
+- rackspace-scaling.gemspec
+homepage: ''
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Gem that lets you scale the number of rackspace instances you have.
+test_files: []