linecook-gem 0.6.10 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ae6258ac3d3dbf0e03203631737b4c98b8889cf7
-  data.tar.gz: 9b0e1c1571e3e0ac148503e91df156e4517a0ebc
+  metadata.gz: 4f0a7a7d8d39c7428d53070807e962a4dfd8bdd9
+  data.tar.gz: 46f4d3352064af2c1e79f7d74cf4a7c92205f8aa
 SHA512:
-  metadata.gz: c89fd5065cd7fa3e11fc2815dadef2d22f6637ad3264d66f3a588e8ee5a16cbc210b995edde1cf63f2a252ed3e44d35ed8274f789a4116a63cace1ff4d11f152
-  data.tar.gz: 5e90c5ee82015828728efeb7184cdfb58477a762d93230f5998e7cb6bf5863f3b8f5e429e7dbb2cc96de70d4a9d964baa03af1eeb3d14745fbdd9286c051e4e3
+  metadata.gz: 7a94f90d4514e3c2f4f9414515cc01d4917b4ab9990f95ab9a9d37bad8fa6ded2e3a7793c6eb15f1994109a6f91205864601af862f763eeeccaa137b2e8622ca
+  data.tar.gz: 517faebb8e971e65698ec12bc8ac03b06fced0d3d167a8d4eff45c4672883bf7a2e50dc29dd91cde7a2923c57839c9551c1fb1dd62ce403d533a110d92f00964

data/lib/linecook-gem.rb

@@ -1,10 +1,8 @@
 $LOAD_PATH.unshift(File.expand_path('../lib', __FILE__))
+require 'fileutils'
 
 require 'active_support/all'
 require 'linecook-gem/version'
-require 'linecook-gem/util/config'
-require 'linecook-gem/util/downloader'
-require 'linecook-gem/image/manager'
-require 'linecook-gem/builder/manager'
-require 'linecook-gem/provisioner/manager'
-require 'linecook-gem/packager/manager'
+require 'linecook-gem/config'
+require 'linecook-gem/baker'
+require 'linecook-gem/packager'

data/lib/linecook-gem/baker.rb

@@ -0,0 +1,110 @@
+require 'thor/shell'
+require 'fileutils'
+require 'kitchen'
+require 'kitchen/command/test'
+
+require 'linecook-gem/image'
+require 'linecook-gem/baker/docker'
+
+module Linecook
+  module Baker
+    class Baker
+
+      def initialize(image, directory: nil)
+        @directory = File.expand_path(directory || Dir.pwd)
+        @image = image
+
+        Dir.chdir(@directory) do
+          load_config
+          munge_config
+          @driver = driver
+        end
+
+      end
+
+      def bake(snapshot: nil, upload: nil, keep: nil)
+
+        FileUtils.mkdir_p(File.join(Dir.pwd, '.kitchen'))
+
+        Dir.chdir(@directory) { @driver.converge }
+
+        snapshot ||= upload
+        if snapshot
+          puts 'Convergence complete, generating snapshot'
+          save
+          @image.upload if upload
+        end
+
+      rescue => e
+        puts e.message
+        puts e.backtrace
+        raise
+      ensure
+        if keep
+          puts "Preserving build #{@image.id}, you will need to clean it up manually."
+        else
+          puts "Cleaning up build #{@image.id}"
+          @driver.instance.destroy
+        end
+      end
+
+      def clean_kitchen
+        Dir.chdir(@directory) do
+          @config.instances.each do |instance|
+            instance.destroy
+          end
+        end
+      end
+
+      def save
+        puts "Saving image to #{@image.path}..."
+        clean
+        @driver.save
+      end
+
+    private
+
+      def clean
+        if @is_chef
+          @driver.exec('userdel -r -f kitchen')
+          @driver.exec('groupdel kitchen')
+          @driver.exec('rm -rf /etc/chef')
+          @driver.exec('rm -rf /tmp/kitchen')
+          @driver.exec('rm -f /etc/sudoers.d/kitchen')
+        end
+      end
+
+      def load_config
+        @config ||= begin
+
+          Kitchen::Config.new(
+            kitchen_root: @directory,
+            loader: Kitchen::Loader::YAML.new(
+              project_config: ENV['KITCHEN_YAML'] || File.join(@directory, '.kitchen.yml'),
+              local_config: ENV['KITCHEN_LOCAL_YAML'],
+              global_config: ENV['KITCHEN_GLOBAL_YAML']
+            )
+          )
+
+        end
+      end
+
+      def munge_config
+        data = @config.send(:data).instance_variable_get(:@data)
+        @is_chef = data[:provisioner][:name] =~ /chef/
+        if Linecook.config[:chef] &&
+            Linecook.config[:chef][:encrypted_data_bag_secret] && @is_chef
+          data[:provisioner][:data_bag_secret] = Linecook.config[:chef][:encrypted_data_bag_secret]
+        end
+
+      end
+
+      def driver
+        case @config.loader.read[:driver][:name]
+        when 'docker'
+          Linecook::Baker::Docker.new(@image, @config)
+        end
+      end
+    end
+  end
+end

data/lib/linecook-gem/baker/docker.rb

@@ -0,0 +1,114 @@
+require 'open3'
+require 'tmpdir'
+require 'fileutils'
+
+require 'docker'
+
+require 'linecook-gem/image'
+
+module Linecook
+  module Baker
+    # FIXME - refactor into a base class with an interface
+    class Docker
+
+      attr_reader :config
+
+      def initialize(image, config)
+        @image = image
+        @config = config
+        munge_config
+      end
+
+
+      def save
+        container.stop
+        FileUtils.mkdir_p(File.dirname(@image.path))
+        pipe, _, _, _ = Open3.popen3("xz -T 0 -0 > #{@image.path}")
+
+        container.export do |chunk|
+          pipe.write(chunk)
+        end
+
+        pipe.flush
+        pipe.close
+        container.start
+      end
+
+      def instance
+        @instance ||= @config.instances.find {|x| @image.name == x.suite.name }
+      end
+
+      def converge
+        instance.converge
+      end
+
+      def stop
+        container.delete(force: true)
+      rescue ::Docker::Error::NotFoundError => e
+        puts e.message
+      end
+
+      def exec(command)
+        command = ['/bin/bash', '-c', command]
+        container.exec(command, tty: true)
+      end
+
+      def inherit(image)
+        puts "Inheriting from #{image.id}..."
+        import(image) unless image_exists?(image)
+        clean_older_images(image)
+      end
+
+    private
+      def container
+        @container ||= ::Docker::Container::get(@image.id)
+      end
+
+      def image_exists?(image)
+        ::Docker::Image.all.find do |docker_image|
+          docker_image.info['RepoTags'].first == "#{image.group}:#{image.tag}"
+        end
+      end
+
+      def clean_older_images(image)
+        puts "Cleaning up older images for #{image.group}..."
+        older_images(image).each do |old|
+          puts "Removing #{old.info['RepoTags'].first}"
+          old.remove(force: true)
+        end
+      end
+
+      def older_images(image)
+        ::Docker::Image.all.select do |docker_image|
+          group, tag = docker_image.info['RepoTags'].first.split(':')
+          group == image.group && tag.to_i < image.tag.to_i
+        end
+      end
+
+      def import(image)
+        puts "Importing #{image.id}..."
+        image.fetch
+        open(image.path) do |io|
+          ::Docker::Image.import_stream(repo: image.group, tag: image.tag, changes: ['CMD ["/sbin/init"]']) do
+            io.read(Excon.defaults[:chunk_size] * 10 ) || ""
+          end
+        end
+      end
+
+
+      # May the gods forgive us for all the rules this breaks
+      def munge_config
+        data = @config.send(:data).instance_variable_get(:@data)
+        data[:driver][:instance_name] = @image.id
+        suite = data[:suites].find{ |n| n[:name] == @image.name }
+        if suite && suite[:inherit]
+          inherited = Linecook::Image.new(suite[:inherit][:name], suite[:inherit][:group], suite[:inherit][:tag])
+          inherit(inherited)
+          data[:driver][:image] = "#{inherited.group}:#{inherited.tag}"
+          data[:driver][:provision_command] ||= []
+          data[:driver][:provision_command] << 'sed -i \'s/\(PasswordAuthentication no\)/#\1/g\' /etc/ssh/sshd_config'
+        end
+      end
+    end
+  end
+end

data/lib/linecook-gem/cli.rb

@@ -1,130 +1,62 @@
 require 'thor'
 require 'linecook-gem'
 
-class Crypto < Thor
-  desc 'keygen', 'Generate AES key for securing images'
+class Image < Thor
+
+  desc 'keygen', 'Generate a new encryption key'
   def keygen
     puts Linecook::Crypto.keygen
   end
 
-  desc 'decrypt IMAGE', ''
-  def decrypt(image)
-    puts Linecook::Crypto.new.decrypt_file(image)
-  end
-
-  desc 'encrypt IMAGE', ''
-  def encrypt(image)
-    puts Linecook::Crypto.new.encrypt_file(image)
-  end
-end
-
-class Image < Thor
-  desc 'crypto SUBCOMMAND', 'Manage image encryption'
-  subcommand 'crypto', Crypto
 
-  desc 'list', 'List images' # add remote flag
-  method_option :type, type: :string, required: false, banner: 'ID', desc: 'Type of image to list', aliases: '-t'
-  method_option :profile, type: :string, default: 'private', banner: 'PROFILE', desc: 'Profile (public/private) of image to list', enum: %w(public private), aliases: '-p'
+  desc 'list', 'List images'
   def list
-    opts = options.symbolize_keys
-    puts Linecook::ImageManager.list(**opts)
-  end
-
-  desc 'latest ID', 'Get the latest image by id' # add remote flag
-  method_option :profile, type: :string, default: 'private', banner: 'PROFILE', desc: 'Profile (public/private) of image to list', enum: %w(public private), aliases: '-p'
-  def latest(id)
-    opts = options.symbolize_keys
-    puts Linecook::ImageManager.latest(id, **opts)
+    puts Linecook::Image.new(nil, nil, nil).list
   end
 
   desc 'fetch', 'Fetch and decrypt an image'
-  method_option :type, type: :string, required: false, banner: 'ID', desc: 'Type of image to list', aliases: '-t'
-  method_option :latest, type: :boolean, default: false, desc: 'Use the latest build for type', aliases: '-l'
-  method_option :name, type: :string, required: false, banner: 'NAME', desc: 'Name of the image to snapshot. Specify this, or --latest with a type', aliases: '-n'
+  method_option :name, type: :string, required: true, banner: 'NAME', desc: 'Name of the image to fetch.', aliases: '-n'
+  method_option :tag, type: :string, default: 'latest', banner: 'NAME', desc: 'Tag of the image to fetch.', aliases: '-t'
+  method_option :group, type: :string, required: false, banner: 'ID', desc: 'Group of image to list', aliases: '-g'
   def fetch
-    fail 'Must specify image name or use latest' unless options[:name] || options[:latest]
-    fail 'Must specify type if specifying latest' if options[:latest] && !options[:type]
-
-    image = options[:latest] ? { type: options[:type], name: :latest } : options[:name].to_sym
-    Linecook::ImageManager.fetch(image)
-  end
-
-  desc 'clean', 'Clean up cached images'
-  method_option :type, type: :string, required: true, banner: 'ID', desc: 'Type of image to list', aliases: '-t'
-  def clean
     opts = options.symbolize_keys
-    puts Linecook::ImageManager.clean(**opts)
-  end
-
-  desc 'upload IMAGE', 'Upload an image'
-  method_options name: :string
-  def upload(image)
-    Linecook::ImageManager.upload(image)
+    image = Linecook::Image.new(opts[:name], opts[:group], opts[:tag] )
+    image.fetch
   end
 
-  desc 'url IMAGE', 'Get URL for image'
-  method_option :type, type: :string, required: false, banner: 'ID', desc: 'Type of image to list', aliases: '-t'
-  def url(image)
+  desc 'upload', 'Upload an image'
+  method_option :name, type: :string, required: true, banner: 'NAME', desc: 'Name of the image to upload.', aliases: '-n'
+  method_option :tag, type: :string, default: 'latest', banner: 'NAME', desc: 'Tag of the image to upload.', aliases: '-t'
+  method_option :group, type: :string, required: false, banner: 'ID', desc: 'Group of image to group', aliases: '-g'
+  def upload
     opts = options.symbolize_keys
-    puts Linecook::ImageManager.url(image, **opts)
+    image = Linecook::Image.new(opts[:name], opts[:group], opts[:tag] )
+    image.upload
   end
 
   desc 'package', 'Package image'
-  method_option :name, type: :string, required: false, banner: 'NAME', desc: 'Name of the image to snapshot. Specify this, or --latest with a type', aliases: '-n'
-  method_option :latest, type: :boolean, default: false, desc: 'Use the latest build for type', aliases: '-l'
-  method_option :ami, type: :boolean, default: true, desc: 'Create an ami', aliases: '-a'
-  method_option :type, type: :string, required: false, banner: 'ID', desc: 'Type of image to snapshot', aliases: '-t'
+  method_option :name, type: :string, required: true, banner: 'NAME', desc: 'Name of the image to package.', aliases: '-n'
+  method_option :tag, type: :string, default: 'latest', banner: 'NAME', desc: 'Tag of the image to package.', aliases: '-t'
+  method_option :group, type: :string, required: false, banner: 'ID', desc: 'Group of image to package', aliases: '-g'
+  method_option :strategy, type: :string, default: 'packer', banner: 'STRATEGY', enum: ['packer', 'squashfs'], desc: 'Packaging strategy', aliases: '-s'
   def package
-    fail 'Must specify image name or use latest' unless options[:name] || options[:latest]
-    fail 'Must specify type if specifying latest' if options[:latest] && !options[:type]
-    name = options[:latest] ? Linecook::ImageManager.latest(options[:type]) : options[:name]
-    Linecook::Packager.package(name, type: options[:type], ami: options[:ami])
-  end
-end
-
-class Builder < Thor
-  desc 'info', 'Show builder info'
-  def info
-    puts Linecook::Builder.info
-  end
-
-  desc 'start', 'Start the builder'
-  def start
-    Linecook::Builder.start
-  end
-
-  desc 'stop', 'Stop the builder'
-  def stop
-    Linecook::Builder.stop
-  end
-
-  desc 'ip', 'Show the external ip address of the builder'
-  def ip
-    puts Linecook::Builder.ip
-  end
-end
-
-class Build < Thor
-  desc 'list', 'Show all builds'
-  def list
-    puts Linecook::Builder.builds
-  end
-
-  desc 'info', 'Show build info'
-  def info
+    opts = options.symbolize_keys
+    image = Linecook::Image.new(opts[:name], opts[:group], opts[:tag])
+    Linecook::Packager.package(image, name: opts[:strategy])
   end
 
-  desc 'ip', 'Show IP address for build'
-  def ip
+  desc 'save', 'Save running build'
+  method_option :name, type: :string, required: true, banner: 'NAME', desc: 'Name of the image to package.', aliases: '-n'
+  method_option :tag, type: :string, default: 'latest', banner: 'NAME', desc: 'Tag of the image to package.', aliases: '-t'
+  method_option :group, type: :string, required: false, banner: 'ID', desc: 'Group of image to package', aliases: '-g'
+  method_option :directory, type: :string, required: false, banner: 'DIR', desc: 'Directory containing kitchen files', aliases: '-d'
+  def save
+    opts = options.symbolize_keys
+    image = Linecook::Image.new(opts[:name], opts[:group], opts[:tag])
+    baker = Linecook::Baker::Baker.new(image, directory: opts[:directory])
+    baker.save
   end
 
-  desc 'snapshot', 'Take a snapshot of the build with NAME'
-  method_option :name, type: :string, required: true, banner: 'ROLE_NAME', desc: 'Name of the role to build', aliases: '-n'
-  method_option :resume, type: :boolean, default: false,  desc: 'Resume the build after snapshotting it', aliases: '-r'
-  def snapshot
-    build = Linecook::Build.new(name, '')
-    build.snapshot(save: true)
-  end
 end
 
 class Linecook::CLI < Thor
@@ -132,24 +64,40 @@ class Linecook::CLI < Thor
   desc 'image SUBCOMMAND', 'Manage linecook images.'
   subcommand 'image', Image
 
-  desc 'builder SUBCOMMAND', 'Manage the builder.'
-  subcommand 'builder', Builder
-
-  desc 'build SUBCOMMAND', 'Manage running and completed builds.'
-  subcommand 'build', Build
-
   desc 'bake', 'Bake a new image.'
   method_option :name, type: :string, required: true, banner: 'ROLE_NAME', desc: 'Name of the role to build', aliases: '-n'
+  method_option :group, type: :string, required: false, banner: 'CLASS', desc: 'Optional class for a build', aliases: '-g'
   method_option :tag, type: :string, required: false, banner: 'TAG', desc: 'Optional tag for a build', aliases: '-t'
-  method_option :id, type: :string, required: false, banner: 'ID', desc: 'Optional id for a build', aliases: '-i'
-  method_option :keep, type: :boolean, default: true, desc: 'Keep the build running when done', aliases: '-k'
-  method_option :clean, type: :boolean, default: false, desc: 'Clean up all build artifacts', aliases: '-c'
-  method_option :build, type: :boolean, default: true, desc: 'Build the image', aliases: '-b'
+  method_option :directory, type: :string, required: false, banner: 'DIR', desc: 'Directory containing kitchen files', aliases: '-d'
+  method_option :keep, type: :boolean, default: false, desc: 'Keep the build running when done', aliases: '-k'
   method_option :snapshot, type: :boolean, default: false, desc: 'Snapshot the resulting build to create an image', aliases: '-s'
-  method_option :upload, type: :boolean, default: false, desc: 'Upload the resulting build. Implies --snapshot and --encrypt.', aliases: '-u'
-  method_option :package, type: :boolean, default: false, desc: 'Package the resulting image. Implies --upload, --snapshot and --encrypt.', aliases: '-p'
+  method_option :upload, type: :boolean, default: false, desc: 'Upload the resulting build. Implies --snapshot.', aliases: '-u'
+  #method_option :package, type: :boolean, default: false, desc: 'Package the resulting image. Implies --upload and --snapshot', aliases: '-p'
   def bake
     opts = options.symbolize_keys
-    Linecook::Baker.bake(**opts)
+    image = Linecook::Image.new(opts[:name], opts[:group], opts[:tag])
+    baker = Linecook::Baker::Baker.new(image, directory: opts[:directory])
+    baker.bake(snapshot: opts[:snapshot], upload: opts[:upload], keep: opts[:keep])
+  end
+
+  desc 'clean', 'Clean up the kitchen, destroy all builds'
+  method_option :directory, type: :string, required: false, banner: 'DIR', desc: 'Directory containing kitchen files', aliases: '-d'
+  def clean
+    opts = options.symbolize_keys
+    image = Linecook::Image.new(nil, nil, nil)
+    baker = Linecook::Baker::Baker.new(image, directory: opts[:directory])
+    baker.clean_kitchen
+  end
+
+  desc 'man', 'Show the manpage'
+  def man
+    path = File.join(Gem::Specification.find_by_name('linecook-gem').gem_dir, 'man', 'LINECOOK.1' )
+    system("man #{path}")
   end
+
+  desc 'version', 'Print the current version'
+  def version
+    puts Linecook::VERSION
+  end
+
 end