ramdev 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: d1c089e4b0d2b4a795153868719ac311302c3a92
+  data.tar.gz: e6a958654bbeb09344c16f906219497c750d7b8f
+SHA512:
+  metadata.gz: 0c9f1ca55b4de6dc19b1cdea012b9bb9fb80d41381ccb578202fa3bb6549001f04b19e26b01e7e3c87d39bb7d15dec4caed19f46ffe8249fdb06deadcf18e30b
+  data.tar.gz: e499a8830accb95d90119b1fecfdd360eee8390a0cf3135052198658da96963b09500fd753e97604d16226cbedb65927cf7102d06bea344d773c8d8ee838df86

data/bin/ramdev

@@ -0,0 +1,37 @@
+#!/usr/bin/env ruby
+
+require 'main'
+require 'ramdev'
+require 'etc'
+
+#TODO: Override the rc file from the command line
+#FIX: This is not windows compatible.
+
+Main do
+  mode 'up' do
+    def run
+      user = Etc.getlogin
+      rcfile = File.join(Dir.home(user), ".ramdevrc")
+
+      rd = RamDev.new
+      rd.build(rcfile) #10MB
+    end
+  end
+
+  mode 'down' do
+    def run
+      user = Etc.getlogin
+      rcfile = File.join(Dir.home(user), ".ramdevrc")
+
+      rd = RamDev.new
+      rd.unbuild(rcfile)
+    end
+  end
+
+  def run()
+    puts 'Usage: ramdev [up|down]'
+    puts ''
+    puts "\tup\tCreate a ramdisk, move and link working folders."
+    puts "\tdown\tDeallocate ramdisk and restore all file paths."
+  end
+end

data/bin/ramdev_sync

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require 'ramdev_sync'
+
+watcher = RamDevSync.new(ARGF.read)
+
+trap("QUIT") do
+  puts "Interrupted by normal shutdown signal, ramdev_sync will stop now."
+  watcher.remove_log
+  exit
+end
+
+watcher.listen
+sleep

data/lib/ramdev.rb

@@ -0,0 +1,397 @@
+require 'ramdisk'
+require 'ramdev_sync'
+require 'pstore'
+require 'fileutils'
+
+class RamDev
+  attr_reader :diskname, :ramdisk, :mountpoint
+    #path to rc file, and 10 mb default size.
+
+  def initialize(sufix = "_ramdev")
+    @backupSuffix = sufix
+    @store = PStore.new("/tmp/ramdev.pstore")
+  end
+
+  def unbuild(rcpath)
+    #TODO force sync
+    load_runcom(rcpath)
+
+    if !restore_folders
+      puts "Ramdisk shutdown was halted because there was a problem restoring folders."
+      puts "Eject the ramdisk manually once you've sorted out any issues."
+      return
+    end
+    ramdisk = Ramdisk.new(mountpoint)
+
+    pid = @store.transaction do |s|
+      s["pid"]
+    end
+
+    Process.kill("QUIT", pid) if pid
+
+    ramdisk.unmount
+    ramdisk.deallocate
+
+    "RAM disk removed at #{mountpoint}"
+  end
+
+  def memory
+    if @memory.nil?
+      r = `/usr/sbin/system_profiler SPHardwareDataType`.split("\n").collect { |s| s == "" ? nil : s.strip }.compact
+      r = r.collect { |s| s.split(":").collect { |ss| ss.strip }}
+      memstring = ""
+      r.each do |i|
+        memstring = i[1] if i[0] == "Memory"
+      end
+      @memory = memstring.match(/([0-9]+) GB/)[1].to_i * 1073741824
+    end
+    @memory
+  end
+
+  def build(rcpath, size = nil)
+    @size = size
+    @size ||= memory / 2
+    load_runcom(rcpath)
+
+
+    ramdisk = Ramdisk.new(mountpoint)
+
+    puts "Allocating ramdisk size: #{@size / 1073741824} GB "
+    if( !ramdisk.allocate(@size) )
+      puts "Allocation failed. Size: #{@size} bytes"
+      exit
+    end
+    if( !ramdisk.format(diskname, :hfs) )
+      puts "Failed to format disk."
+      exit
+    end
+    if( !ramdisk.mount )
+      puts "Failed to mount at #{mountpoint}"
+      ramdisk.deallocate
+      exit
+    end
+
+
+    copy_folders if valid_paths?
+
+    puts "RAM disk mounted at #{mountpoint}"
+
+    #FIX: Not compatible with Windows:
+
+
+
+
+    fork do
+      puts "ramdev_sync pid #{Process.pid}"
+
+      @store.transaction do |s|
+        s["pid"] = Process.pid
+      end
+
+      trap("QUIT") do
+        puts "Interrupted by signal, ramdev_sync will stop now."
+        exit
+      end
+
+      watcher = RamDevSync.new(File.open(rcpath))
+      watcher.listen
+      puts "ramdev_sync listening..."
+      sleep
+    end
+
+  end
+
+  def load_runcom(rcfile)
+
+    return if @loaded == true
+    rc = YAML.load(File.open(rcfile))
+    if rc.nil?
+      @mountpoint = "/ramdev"
+      @diskname   = "ramdev"
+      @paths      ||= []
+      @paths.push({ source: Dir.pwd, destination: "" })
+    else
+      @mountpoint = rc["ramdisk"]["mountpoint"]
+      @diskname  = rc["ramdisk"]["name"]
+        # TODO: Get size of paths and create default ramdisk size based it (2x)
+      @paths     = rc["ramdisk"]["paths"]
+      @size      ||= rc["ramdisk"]["size"] if rc["ramdisk"]["size"]
+      @loaded    = true
+    end
+
+  end
+
+  def valid_paths?
+    @paths.each do |p|
+      src   = p["source"].gsub(/\/+$/,"")
+      if File.exist?("#{src}#{@backupSuffix}")
+        puts "A backup already exists for: '#{src}' at: '#{src}#{@backupSuffix}'"
+        return false
+      end
+    end
+    return true
+  end
+
+  def restore_folders
+    @paths.each do |p|
+      src   = p["source"].gsub(/\/+$/,"")
+
+      if !File.exists? src+@backupSuffix || !File.symlink?(src)
+        puts "Referenced files don't appear to be linked properly. "
+        return false
+      end
+    end
+
+    @paths.each do |p|
+      src   = p["source"].gsub(/\/+$/,"")
+      FileUtils.safe_unlink src
+      FileUtils.move(src+@backupSuffix, src)
+    end
+    true
+  end
+
+  def copy_folders
+    @paths.each do |p|
+      src   = p["source"].gsub(/\/+$/,"")
+      next if src.nil? || src.length < 1
+      des   = p["destination"].gsub(/\/+$/,"").gsub(/^\/+/,"")
+      name  = src.match(/([^\/\\]+)$/)[1]
+      if des.length > 0
+        des = mountpoint+"/#{des}"
+        des = des.gsub(/\/{2,}/,"/")
+      else
+        des = mountpoint
+      end
+      des = File.absolute_path(des)
+      print "Copying #{src}...\n"
+      FileUtils.mkdir_p(des) unless File.exist?(des)
+      IO.popen("rsync --progress -ra #{src} #{des}") do |rsync_io|
+        until rsync_io.eof?
+          line = rsync_io.readline
+          line = line.gsub("\n","")
+          next unless line =~ /to-check/
+          m = line.match(/to-check=([0-9]+)\/([0-9]+)/)
+          scale = (m[1].to_f / m[2].to_f)
+          prog = "#{[9613].pack('U*')}" * ( (1.0 - scale) * 30.0).round
+
+          prog += " " * (scale * 30.0).round
+          print "#{prog}| #{des}/#{name}  "
+          print "\r"
+        end
+      end
+      print "\n"
+
+      FileUtils.move(src, src+@backupSuffix)
+
+      puts "Linking: #{name}"
+
+      File.symlink("#{des}/#{name}", src)
+    end
+  end
+
+end
+
+
+# require 'etc'
+# require 'yaml'
+# require 'fileutils'
+
+
+#class RamDev
+  #-------
+  # attr_reader :ramDiskSize, :sectors
+
+  # def initialize
+  #   @backupSuffix = "_backup_DEV"
+  #   @systemInfo = SystemInfo.new
+  #   @ramDiskSize = (@systemInfo.memory / 2)
+  # end
+
+  # def build(diskname = "x", mountpoint = "/x", paths = [])
+  #   unbuild(diskname, mountpoint, paths)
+  #   build = false
+
+  #   if @ramDiskSize > 0
+  #     @sectors = @ramDiskSize / 512
+
+  #     ramdisk = `hdid -nomount ram://#{sectors}`.strip
+  #     system "newfs_hfs -v '#{diskname}' #{ramdisk}"
+  #     build = system "sudo mount -o noatime -t hfs #{ramdisk} #{mountpoint}"
+  #     print "RAM disk mounted at #{mountpoint}\n"
+
+  #     if build
+  #       paths.each do |p|
+  #         print "#{p}\n"
+  #         src   = p["source"].gsub(/\/+$/,"")
+  #         validate(src)
+  #       end
+  #       paths.each do |p|
+  #         src   = p["source"].gsub(/\/+$/,"")
+  #         next if src.nil? || src.length < 1
+  #         des   = p["destination"].gsub(/\/+$/,"").gsub(/^\/+/,"")
+  #         name  = src.match(/([^\/\\]+)$/)[1]
+  #         if des.length > 0
+  #           des = mountpoint+"/#{des}"
+  #           des = des.gsub(/\/{2,}/,"/")
+  #         else
+  #           des = mountpoint
+  #         end
+  #         print "Copying #{src}...\n"
+  #         FileUtils.mkdir_p(des) if !File.exist?(des)
+  #         IO.popen("rsync --progress -ra #{src} #{des}") do |rsync_io|
+  #           until rsync_io.eof?
+  #             line = rsync_io.readline
+  #             line = line.gsub("\n","")
+  #             next unless line =~ /to-check/
+  #             m = line.match(/to-check=([0-9]+)\/([0-9]+)/)
+  #             scale = (m[1].to_f / m[2].to_f)
+  #             prog = "#{[9613].pack('U*')}" * ( (1.0 - scale) * 30.0).round
+
+  #             prog += " " * (scale * 30.0).round
+  #             print "#{prog}| #{des}/#{name}  "
+  #             print "\r"
+  #           end
+  #         end
+  #         print "\n"
+
+  #         FileUtils.move(src, src+@backupSuffix)
+
+  #         puts "Linking: #{name}"
+
+  #         File.symlink("#{des}/#{name}", src)
+  #       end
+  #     end
+  #   end
+  # end
+
+  # def unbuild(diskname = "x", mountpoint = "/x", paths = [])
+  #   paths.each do |p|
+  #     print "#{p}\n"
+  #     src   = p["source"].gsub(/\/+$/,"")
+  #     next if src.nil? || src.length < 1
+  #     des   = p["destination"].gsub(/\/+$/,"").gsub(/^\/+/,"")
+  #     name  = src.match(/([^\/\\]+)$/)[1]
+
+  #     if File.exists? src+@backupSuffix
+  #       FileUtils.safe_unlink src if File.symlink?(src)
+  #       if File.exist?(src)
+  #         print "Conflict between #{src} and #{src+@backupSuffix}"
+  #         next
+  #       end
+  #       FileUtils.move(src+@backupSuffix, src)
+  #     end
+  #   end
+
+  #   unmount = `diskutil unmount force #{mountpoint}`
+  #   if unmount =~ /Volume .* on (.*) unmounted/
+  #     m = unmount.match(/Volume .* on (.*) unmounted/)
+  #     system "hdiutil detach /dev/#{m[1]}"
+  #   else
+  #     print unmount
+  #   end
+  # end
+
+  # private
+
+  # def validate(src)
+  #   if File.exist?("#{src}#{@backupSuffix}")
+  #     abort "Stopping for safety. A backup already exists for: '#{src}' at: '#{src}#{@backupSuffix}'"
+  #   end
+  # end
+
+#end
+
+
+# if opts.ram?
+#   print "Building RAM disk"
+#   rd = RamDev.new opts[:ram]
+#   rd.build(rc["ramdisk"]["name"],rc["ramdisk"]["mountpoint"],rc["ramdisk"]["paths"])
+# elsif opts.fix?
+#   print "fixing links"
+#   rd = RamDev.new opts[:ram]
+#   rd.unbuild(rc["ramdisk"]["name"],rc["ramdisk"]["mountpoint"],rc["ramdisk"]["paths"])
+# end
+
+
+# def getrc
+#   si = SystemInfo.new
+#   si.loadOrCreateRC
+# end
+
+# def build_ramdisk
+#   rc = getrc
+#   rd = RamDev.new #options?
+#   rd.build(rc["ramdisk"]["name"],rc["ramdisk"]["mountpoint"],rc["ramdisk"]["paths"])
+# end
+
+# def teardown_ramdisk
+#   rc = getrc
+#   rd = RamDev.new #options?
+#   rd.unbuild(rc["ramdisk"]["name"],rc["ramdisk"]["mountpoint"],rc["ramdisk"]["paths"])
+# end
+
+# -------------------
+
+#require 'main'
+
+# Main do
+#   mode 'up' do
+#     def run
+#       puts 'building RAMDISK...'
+#       build_ramdisk
+#     end
+#   end
+
+#   mode 'down' do
+#     def run
+#       puts 'tearing down RAMDISK...'
+#       teardown_ramdisk
+#     end
+#   end
+
+#   mode 'aws' do
+#     def run
+#       puts 'do something with AWS...'
+#     end
+#   end
+
+#   def run()
+#     puts 'doing something different'
+#   end
+# end
+# class SystemInfo
+
+#   def memory
+#     if @memory.nil?
+#       r = `/usr/sbin/system_profiler SPHardwareDataType`.split("\n").collect { |s| s == "" ? nil : s.strip }.compact
+#       r = r.collect { |s| s.split(":").collect { |ss| ss.strip }}
+#       memstring = ""
+#       r.each do |i|
+#         memstring = i[1] if i[0] == "Memory"
+#       end
+#       @memory = memstring.match(/([0-9]+) GB/)[1].to_i * 1073741824
+#     end
+#     @memory
+#   end
+
+#   def home
+#     @home ||= Dir.home(user)
+#   end
+
+#   def user
+#     @user ||= Etc.getlogin
+#   end
+
+#   def loadOrCreateRC
+#     rcpath = "#{home}/.devrc"
+#     unless File.exist? rcpath
+#       File.open(rcpath, "w") do |f|
+#         f.puts '# This is a yaml format file with settings for "dev".'
+#         f.puts '# See dev -h for more information.'
+#       end
+#     end
+#     puts "Loading devrc: #{rcpath}"
+#     YAML.load_file rcpath
+#   end
+
+# end

data/lib/ramdev_sync.rb

@@ -0,0 +1,87 @@
+#!/usr/bin/env ruby
+
+require 'listen'
+require 'yaml'
+# require 'pstore'
+# store = PStore.new("ramdev_sync.pstore")
+
+class RamDevSync
+  attr_reader :paths, :listener
+
+  def initialize(rcpath, sufix = "_ramdev")
+    @backupSuffix = sufix
+    load_runcom(rcpath)
+
+    # store.transaction do |s|
+    # end
+  end
+
+    #FIX: This is *almost* duplicated from ramdev.rb:
+  def load_runcom(rcpath)
+
+    return if @loaded == true
+
+    rc = YAML.load(rcpath)
+    if rc.nil?
+      @mountpoint = "/ramdev"
+      @diskname   = "ramdev"
+      @paths      = []
+
+      for pathset in rc["ramdisk"]["paths"] do
+        @paths.push([Dir.pwd, "#{@mountpoint}"])
+      end
+    else
+      @mountpoint = rc["ramdisk"]["mountpoint"]
+      @diskname  = rc["ramdisk"]["name"]
+      @paths     = []
+        # TODO: Get size of paths and create default ramdisk size (x2)
+      for pathset in rc["ramdisk"]["paths"] do
+        @paths.push([pathset["source"], "#{@mountpoint}/#{pathset['destination']}"])
+      end
+
+      @loaded    = true
+
+    end
+    puts "ramdev_sync configured for: #{@mountpoint}"
+  end
+
+  def running?
+    return true if !@listener.nil? && @listener.listen?
+    return false
+  end
+
+  def watchpaths
+    return @paths.collect do |i|
+        # path being watched
+      ["#{i[1]}/#{i[0][/([^\/]*)\/*$/,1]}".gsub(/\/{2,}/,"/"),
+          # origin path to sync to
+      "#{i[0][/(.*[^\/]+)\/*$/,1]}#{@backupSuffix}".gsub(/\/{2,}/,"/")]
+    end
+  end
+
+  def listen
+    @listener = Listen.to watchpaths.collect { |i| i[0]} do |modified, added, removed|
+      rsync [modified,added,removed]
+    end
+    @listener.start # not blocking
+  end
+
+  def rsync(change_list)
+    list = change_list.flatten
+    for wp in watchpaths
+      list.each do |i|
+        if i.include? wp[0]
+          system("date >> /tmp/ramdev_sync_#{Process.pid}.log")
+          system("rsync -a --delete -v --stats \"#{wp[0]}/\" \"#{wp[1]}/\" >> /tmp/ramdev_sync_#{Process.pid}.log"  )
+          break
+        end
+      end
+    end
+
+  end
+
+  def remove_log
+    File.delete("/tmp/ramdev_sync_#{Process.pid}.log")
+  end
+
+end

data/lib/ramdisk.rb

@@ -0,0 +1,173 @@
+require 'plist'
+
+class SystemInfo
+
+  def self.hdiutil(sectors)
+    `hdiutil attach -nomount ram://#{sectors}`
+  end
+
+  def self.newfs_hfs(diskname, ramdisk)
+    `newfs_hfs -v '#{diskname}' #{ramdisk}`
+  end
+
+  def self.mount(mountpoint, ramdisk)
+    system("mount -o noatime -t hfs #{ramdisk} #{mountpoint}")
+  end
+
+  def self.sudomount(mountpoint, ramdisk)
+    system("sudo mount -o noatime -t hfs #{ramdisk} #{mountpoint}")
+  end
+
+  def self.unmount(mountpoint)
+    system("umount -f #{mountpoint}")
+  end
+
+  def self.sudounmount(mountpoint, ramdisk)
+    system("sudo hdiutil eject -force #{mountpoint}")
+  end
+
+  def self.deallocate(ramdisk)
+    raise "Deallocate called with nil device." if ramdisk.nil?
+    `hdiutil detach #{ramdisk}`
+    device = ramdisk[/\/*([^\/]*)$/,1]
+    return "\"#{device}\" unmounted.\n\"#{device}\" ejected.\n"
+  end
+
+  def self.read_hdutil
+    plist = Plist::parse_xml(`hdiutil info -plist`)
+
+    diskImages = []
+    plist.each do |n|
+      diskImages.concat n[1] if n[0] == "images"
+    end
+
+    response = []
+    diskImages.each do |i|
+      if i["image-path"] =~ /^ram\:\/\//
+        response.push([i["system-entities"][0]["dev-entry"], i["system-entities"][0]["mount-point"]])
+      end
+    end
+
+    response
+  end
+
+
+  def self.ramdisks
+      # cannot be ||= because state may have changed.
+    @@ramdisks = read_hdutil
+  end
+
+end
+
+
+  # class that represents all information associated with a ram disk
+class Ramdisk
+
+  attr_accessor :system_interface, :mountpoint, :size, :name, :ramdisk
+
+  def initialize(mountpoint, system_interface = SystemInfo)
+    self.mountpoint = mountpoint
+    self.system_interface = system_interface
+  end
+
+  def unmounted=(m)
+    @unmounted = m
+  end
+
+  def unmounted
+    @unmounted ||= []
+  end
+
+  def mounted?
+    list.each do |i|
+      return true if i[1] =~ /#{mountpoint}$/
+    end
+    return false
+  end
+
+  def list
+      # cannot be ||= because state may have changed.
+    @list = system_interface.ramdisks
+  end
+
+  def ramdisk=(device)
+    @ramdisk = device
+  end
+
+  def ramdisk
+    return @ramdisk if !@ramdisk.nil?
+    list.each do |i|
+      if i[1] =~ /#{mountpoint}$/
+        @ramdisk = i[0]
+        break
+      end
+    end
+    @ramdisk
+  end
+
+  def allocate(size)
+    sectors = size / 512
+    self.ramdisk = system_interface.hdiutil(sectors).strip
+  end
+
+  def deallocate
+    unmounted.each do |u|
+      msg = system_interface.deallocate(u)
+      if !msg =~ /.*unmounted\./
+        raise "ramdisk: #{u} failed to deallocate ramdisk with this message: #{msg}"
+      end
+    end
+    unmounted = []
+    return true
+  end
+
+  def format(drivename = "ramdev", fileSystemFormat = :hfs)
+    self.name = drivename
+    case fileSystemFormat
+    when :hfs
+      msg = system_interface.newfs_hfs(name,ramdisk)
+      if msg =~ /Initialized .*#{ramdisk[/\/*([^\/]*)$/,1]} as a/
+        return true
+      else
+        raise "ramdisk failed to format HFS volume #{ramdisk}"
+      end
+    else
+      raise "ramdisk doesn't understand how to build #{fileSystemFormat} file system"
+    end
+    return flase
+  end
+
+  def mount
+    if system_interface.mount(mountpoint, ramdisk)
+      return true
+    else
+      puts "Unable to mount, trying again with 'sudo'"
+      if system_interface.sudomount(mountpoint, ramdisk)
+        return true
+      else
+        puts "ramdisk failed to mount"
+        return false
+      end
+    end
+  end
+
+  def unmount
+    unmounted_device = ramdisk
+    if system_interface.unmount(mountpoint)
+      unmounted.push(unmounted_device)
+      return true
+    else
+      puts "Unable to unmount, trying again with 'sudo'."
+      if system_interface.sudounmount(mountpoint, unmounted_device)
+        return true
+      else
+        puts "ramdisk failed to un-mount."
+        return false
+      end
+    end
+  end
+
+  # def unmount(mountpoint)
+  # end
+end
+

metadata

@@ -0,0 +1,94 @@
+--- !ruby/object:Gem::Specification
+name: ramdev
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Joshua Kolden
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-12-26 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: listen
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: main
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0.0'
+- !ruby/object:Gem::Dependency
+  name: plist
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 3.1.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 3.1.0
+description: A management tool for creating a ramdrive and syncing folders back to
+  the hard drive automatically while you work.
+email:
+- joshua@crackcreative.com
+executables:
+- ramdev
+- ramdev_sync
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/ramdev.rb
+- lib/ramdev_sync.rb
+- lib/ramdisk.rb
+- bin/ramdev
+- bin/ramdev_sync
+homepage: https://github.com/JoshuaKolden/RamDev
+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.1.11
+signing_key: 
+specification_version: 4
+summary: Work in ram for ultra high performance.
+test_files: []