goatos-base 0.0.1

data/lib/goatos/blends/slave.rb

@@ -0,0 +1,31 @@
+require 'goatos/blends/helper'
+
+module GoatOS
+  module Blends
+    module Slave
+      def add_slave_tasks(sched, options )
+
+        sched.ssh_task 'sudo apt-get update -y'
+
+        sched.ssh_task 'run chef' do
+          execute 'sudo chef-client --no-fork -o recipe[goatos::lxc_install]'
+        end
+
+        sched.ssh_task 'run chef' do
+          execute 'sudo chef-client --no-fork -o recipe[goatos::lxc_configure]'
+        end
+
+        sched.ssh_task 'reboot instance' do
+          execute 'sudo reboot'
+          ignore_failure true
+        end
+
+        sched.ruby_task 'sleep 90s' do
+          execute do |h|
+            sleep 90
+          end
+        end
+      end
+    end
+  end
+end

data/lib/goatos/builder.rb

@@ -0,0 +1,74 @@
+require 'goatos/blends/master'
+require 'goatos/blends/slave'
+require 'goatos/blends/helper'
+require 'chef/knife/bootstrap'
+require 'chef/knife/cookbook_upload'
+require 'chef/knife/role_from_file'
+require 'goatos/log'
+require 'goatos/blends/bootstrap'
+
+module GoatOS
+  module Builder
+    include Blends::Master
+    include Blends::Slave
+    include Blends::Bootstrapper
+
+    def build_master( options )
+      ssh_options = ssh_opts(options)
+      host = options[:host]
+      node_name = options[:name]
+      Blender.blend( 'build_master') do |sched|
+        sched.config(:ssh, ssh_options.merge(stdout: $stdout))
+        sched.members([ host])
+        add_master_tasks( sched, node_name, options )
+        add_bootstrap_tasks( sched, node_name, options )
+        add_sshkey_task(sched, node_name)
+        add_chef_run_task(sched, node_name, 'role[master]')
+      end
+    end
+
+    def build_slave( options )
+      ssh_options = ssh_opts(options)
+      host = options[:host]
+      node_name = options[:name]
+      Blender.blend( 'build_slave') do |sched|
+        sched.config(:ssh, ssh_options.merge(stdout: $stdout))
+        sched.members([ host])
+        add_bootstrap_tasks( sched, node_name, options )
+        add_slave_tasks( sched, options )
+        add_chef_run_task(sched, node_name, 'role[slave]')
+      end
+    end
+
+    def build_standalone( options )
+      ssh_options = ssh_opts(options)
+      host = options[:host]
+      node_name = options[:name]
+      Blender.blend( 'build_standalone') do |sched|
+        sched.config(:ssh, ssh_options.merge(stdout: $stdout))
+        sched.members([ host])
+        add_master_tasks( sched, node_name, options)
+        add_bootstrap_tasks( sched, node_name, options )
+        add_chef_run_task(sched, node_name, 'role[master]')
+        add_sshkey_task(sched, node_name)
+        sched.ruby_task 'avoid stale chef search' do
+          execute do |h|
+            sleep 10
+          end
+        end
+        add_slave_tasks( sched, options )
+        add_chef_run_task(sched, node_name, 'role[standalone]')
+      end
+    end
+
+    def ssh_opts(options)
+      ssh_options = {user: options[:user], port: options[:ssh_port]}
+      if options[:password]
+        ssh_options[:password] = options[:password]
+      elsif options[:key]
+        ssh_options[:keys] = Array( options[:key] )
+      end
+      ssh_options
+    end
+  end
+end

data/lib/goatos/cli.rb

@@ -0,0 +1,190 @@
+require 'goatos/log'
+require 'highline/import'
+require 'goatos/builder'
+require 'goatos/cli/lxc'
+require 'thor'
+require 'thor/group'
+
+module GoatOS
+  class CLI < Thor
+    include Builder
+
+    register GoatOS::CLI::Lxc, :lxc, 'lxc', 'Manage LXC lifecycle'
+
+    desc 'bootstrap -t HOSTNAME -u SSH_USER', 'Bootstrap a server'
+
+    option :host,
+      aliases: '-h',
+      required: true,
+      description: 'Host IP/FQDN'
+
+    option :name,
+      aliases: '-N',
+      description: 'chef node name of the node (default sauron)',
+      default: 'sauron'
+
+    option :type,
+      aliases: '-T',
+      default: 'standalone',
+      description: 'Type of bootstrap ("master", "slave" or "standalone")'
+
+    option :user,
+      aliases: '-u',
+      default: ENV['USER'],
+      description: 'SSH user name'
+
+    option :key,
+      aliases: '-i',
+      description: 'SSH identity key'
+
+    option :password,
+      aliases: '-P',
+      description: 'Password for ssh user',
+      type: :boolean
+
+    option :ssh_port,
+      aliases: '-p',
+      description: 'SSH Port',
+      type: :string,
+      default: '22'
+
+    option :environment,
+      aliases: '-E',
+      description: 'Chef environment',
+      type: :string,
+      default: '_default'
+
+    option :run_list,
+      aliases: '-r',
+      description: 'Chef run list',
+      type: :string
+
+    def bootstrap(cwd = Dir.pwd)
+      opts = options.dup
+      if options[:password]
+        password = ask('SSH Password: '){ |q| q.echo = false }
+        opts.merge!(password: password)
+      end
+      Dir.chdir(cwd) do
+        case options[:type]
+        when 'master'
+          build_master( opts )
+        when 'slave'
+          build_slave( opts )
+        when 'standalone'
+          build_standalone( opts )
+        else
+          abort 'only master, slave or standalone bootstrap is valid'
+        end
+      end
+    end
+
+    desc 'run-chef', 'Run chef across fleet'
+
+    option :user,
+      aliases: '-u',
+      default: ENV['USER'],
+      description: 'SSH user name'
+
+    option :key,
+      aliases: '-i',
+      description: 'SSH identity key'
+
+    option :password,
+      aliases: '-P',
+      description: 'Password for ssh user',
+      type: :boolean
+
+    option :filter,
+      aliases: '-f',
+      default: '*:*',
+      description: 'Search term to predicate host list'
+
+    option :attribute,
+      aliases: '-a',
+      default: 'ipaddress',
+      description: 'Node attribute to be used for ssh hostname'
+
+    option :run_list,
+      aliases: '-r',
+      description: 'Node attribute to be used for ssh hostname'
+
+    def run_chef
+      ssh_opts = { user: options[:user] }
+      if options[:password]
+        password = ask('SSH Password: '){ |q| q.echo = false }
+        ssh_opts[:password] = password
+      else
+        ssh_opts[:keys] = [ options[:key] ]
+      end
+
+      chef_opts= {
+        attribute: options[:attribute],
+        filter: options[:filter],
+      }
+      if options[:run_list]
+        chef_command = "sudo /opt/chef/bin/chef-client --no-fork -o #{options[:run_list]}"
+      else
+        chef_command = 'sudo /opt/chef/bin/chef-client --no-fork'
+      end
+
+      run_blender(
+        chef_command,
+        ssh_opts,
+        chef_opts
+      )
+    end
+
+    desc 'meta', 'Show lxc related metadata'
+    def meta
+      ssh_opts = {
+        keys: [ 'keys/goatos.rsa' ],
+        user: 'goatos'
+      }
+
+      chef_opts= {
+        attribute: options[:attribute],
+        filter: options[:filter],
+      }
+      if options[:show]
+        meta_command = '/opt/goatos/bin/goat-meta show'
+      elsif options[]
+        raise ArgumentError, 'Meta command not implemented'
+      end
+      run_blender(
+        meta_command,
+        ssh_opts,
+        chef_opts
+      )
+    end
+
+    desc 'init', 'Create GoatOS directory structure'
+    def init(cwd = Dir.pwd)
+      Dir.chdir(cwd) do
+        %w{cookbooks keys roles environments etc}.each do |dir|
+          unless File.exist?(dir)
+            Dir.mkdir(dir)
+          end
+        end
+        Dir["#{File.expand_path('../../../roles', __FILE__)}/*.rb"].each do |f|
+          FileUtils.cp( f, "roles/#{File.basename(f)}")
+        end
+        Dir["#{File.expand_path('../../../cookbooks', __FILE__)}/*"].each do |f|
+          FileUtils.cp_r( f, "cookbooks/#{File.basename(f)}")
+        end
+      end
+    end
+
+    no_commands do
+      def run_blender(command, ssh_opts, chef_opts)
+        Blender.blend('goatos_run_chef') do |sched|
+          sched.config(:chef, config_file: 'etc/knife.rb', attribute: chef_opts[:attribute])
+          sched.config(:ruby, stdout: $stdout)
+          sched.config(:ssh, ssh_opts.merge(stdout: $stdout))
+          sched.members(sched.search(:chef, chef_opts[:filter]))
+          sched.ssh_task command
+        end
+      end
+    end
+  end
+end

data/lib/goatos/cli/lxc.rb

@@ -0,0 +1,162 @@
+require 'thor'
+require 'blender/chef'
+
+module GoatOS
+  class CLI < Thor
+    class Lxc < Thor
+      class_option :filter,
+        aliases: '-f',
+        default: '*:*',
+        description: 'Search term to predicate host list'
+      class_option :attribute,
+        aliases: '-a',
+        default: 'ipaddress',
+        description: 'Node attribute to be used for ssh hostname'
+
+      desc 'lxc ls', 'list all lxc'
+      def ls
+        opts = options.dup
+        run_blender('lxc-ls --fancy', opts)
+      end
+
+      desc 'lxc start', 'start a container'
+      option :name,
+        aliases: '-N',
+        required: true,
+        description: 'Name of the container to start'
+      def start
+        opts = options.dup
+        commands = []
+        commands << "lxc-start -d -n #{opts[:name]}"
+        commands << "/opt/goatos/bin/goatos-meta converge #{opts[:name]}"
+        run_blender(commands, opts)
+      end
+
+      desc 'lxc stop', 'stop a container'
+      option :name,
+        aliases: '-N',
+        required: true,
+        description: 'Name of the container to stop'
+      def stop
+        opts = options.dup
+        command = [ 'lxc-stop' ]
+        command += ['-n', opts[:name]]
+        run_blender(command.join(' '), opts)
+      end
+
+      desc 'lxc destroy', 'destroy a container'
+      option :name,
+        aliases: '-N',
+        required: true,
+        description: 'Name of the container to destroy'
+      option :force,
+        aliases: '-f',
+        type: :boolean,
+        description: 'Force destroy (will shutdown a container if its running)'
+      def destroy
+        opts = options.dup
+        commands = [ "lxc-destroy -n #{opts[:name]}" ]
+        commands.first << ' -f' if opts[:force]
+        commands <<  "/opt/goatos/bin/goatos-meta delete #{options[:name]}"
+        run_blender(commands, opts)
+      end
+
+      desc 'lxc create', 'create a container'
+      option :template,
+        default: 'download',
+        aliases: '-t',
+        description: 'Template for building rootfs'
+      option :arch,
+        default: 'amd64',
+        aliases: '-a',
+        description: 'ARCH for the lxc'
+      option :distro,
+        default: 'ubuntu',
+        aliases: '-d',
+        description: 'Disro type to be used with download template'
+      option :release,
+        default: 'trusty',
+        aliases: '-r',
+        description: 'Release of a distribution (e.g lucid, precise, trusty for ubuntu)'
+      option :name,
+        required: true,
+        aliases: '-N',
+        description: 'Name of the container'
+      option :expose,
+        description: 'Network service this container will expose ct_port:protocol:host_port'
+      option :clone,
+        type: :string,
+        description: 'clone a stopped container'
+      option :chef_recipe,
+        type: :string,
+        aliases: '-R',
+        description: 'An chef recipe that will executed upon container start'
+      def create
+        opts = options.dup
+        commands = []
+        if options[:clone]
+          command = [ 'lxc-clone' ]
+          command += [ '-s', '-B', 'overlayfs' ]
+          command += [ opts[:clone], opts[:name] ]
+          commands = [ command.join(' ') ]
+        else
+          command = [ 'lxc-create']
+          command += ['-t', opts[:template]]
+          command += ['-n', opts[:name], '--']
+          command += ['-d', opts[:distro]]
+          command += ['-r', opts[:release]]
+          command += ['-a', opts[:arch]]
+          commands << command.join(' ')
+        end
+        command = [ "/opt/goatos/bin/goatos-meta add #{options[:name]}" ]
+        command += ['-t', opts[:template]]
+        command += ['-d', opts[:distro]]
+        command += ['-r', opts[:release]]
+        command += ['-a', opts[:arch]]
+        if opts[:chef_recipe]
+          command += ['-R', opts[:chef_recipe]]
+        end
+        if options[:expose]
+          command += ['-e', options[:expose]]
+        end
+        commands << command.join(' ')
+        run_blender( commands, opts )
+      end
+
+      desc 'meta ', 'Show lxc related metadata'
+      option :container,
+        type: :string,
+        description: 'Show metadata pertaining to only that container'
+      option :format,
+        type: :string,
+        description: 'Output format, can be text or json',
+        default: 'json'
+      def meta
+        if options[:container]
+          command = "/opt/goatos/bin/goatos-meta show #{options[:container]}"
+        else
+          command = '/opt/goatos/bin/goatos-meta list'
+        end
+        command << " -F #{options[:format]}"
+        run_blender(
+          command,
+          options
+        )
+      end
+
+      no_commands do
+        def run_blender(commands, opts)
+          Blender.blend('goatos_lxc') do |sched|
+            sched.config(:chef, config_file: 'etc/knife.rb', attribute: opts[:attribute])
+            sched.config(:ruby, stdout: $stdout)
+            sched.config(:ssh, stdout: $stdout, user: 'goatos', keys: ['keys/goatos.rsa'])
+            sched.members(sched.search(:chef, opts[:filter]))
+            Array(commands).each do |cmd|
+              sched.ssh_task cmd
+            end
+          end
+        end
+      end
+    end
+  end
+end