machines 0.5.4 → 0.5.6

data/lib/machines/app_settings.rb

@@ -1,5 +1,5 @@
 module Machines
-  module AppSettings
+  class AppSettings
     class AppBuilder < OpenStruct
       def get_binding
         binding

data/lib/machines/cloud_machine.rb

@@ -1,5 +1,5 @@
 module Machines
-  module CloudMachine
+  class CloudMachine
     def connect_to_cloud
       begin
         require 'fog'

data/lib/machines/command.rb

@@ -1,5 +1,3 @@
-require 'machines/logger'
-
 module Machines
   class Command
     class << self

data/lib/machines/commandline.rb

@@ -1,13 +1,29 @@
 module Machines
-  module Commandline
+  class Commandline
+
+    def initialize
+      @core = Core.new
+    end
+
+    # Execute a command (build dryrun generate htpasswd packages override tasks)
+    def self.execute options
+      help = Help.new
+      action = options.shift
+      if help.actions.include?(action)
+        new.send action.gsub('new', 'generate'), options
+      else
+        say help.syntax
+      end
+    end
+
     # Loads Machinesfile, opens an SCP connection and runs all commands and file uploads
     def build options
       $conf.machine_name = options.shift
       return say(Help.new.syntax) unless $conf.machine_name
       init
-      load_machinesfile
+      @core.package 'Machinesfile'
 
-      task options if options.any?
+      @core.task options if options.any?
 
       ssh_options = {:paranoid => false}
       if $conf.machine.cloud
@@ -43,18 +59,6 @@ module Machines
       build options
     end
 
-    # Execute a given command e.g. dryrun, build, generate, htpasswd, packages, override, tasks
-    def execute options
-      help = Help.new
-      action = options.shift
-      if help.actions.include?(action)
-        action = 'generate' if action == 'new'
-        send action, options
-      else
-        say help.syntax
-      end
-    end
-
     def generate options
       dir = options.first || './'
       if File.exists? dir
@@ -85,25 +89,15 @@ module Machines
       $conf.tasks = {}
       $conf.load('config.yml')
 
-      Command.file ||= Machines::Logger.new File.open('log/output.log', 'w')
-      Command.debug ||= Machines::Logger.new File.open('log/debug.log', 'w')
-      Command.console ||= Machines::Logger.new STDOUT, :truncate => true
+      Command.file ||= Logger.new File.open('log/output.log', 'w')
+      Command.debug ||= Logger.new File.open('log/debug.log', 'w')
+      Command.console ||= Logger.new STDOUT, :truncate => true
     end
 
     def list notused
       say Help.new.machine_list
     end
 
-    def load_machinesfile
-      eval File.read('Machinesfile'), nil, "eval: Machinesfile"
-    rescue LoadError => e
-      if e.message =~ /Machinesfile/
-        raise LoadError, "Machinesfile does not exist. Use `machines new <DIR>` to create a template."
-      else
-        raise
-      end
-    end
-
     def packages notused
       say 'Default packages'
       Dir[File.join($conf.application_dir, 'packages', '**/*.rb')].each do |package|
@@ -136,7 +130,7 @@ module Machines
 
       $conf.log_only = true
       init
-      load_machinesfile
+      @core.package 'Machinesfile'
       say 'Tasks'
       $conf.tasks.each do |task_name, settings|
         say "  %-20s #{settings[:description]}" % task_name

data/lib/machines/commands/checks.rb

@@ -0,0 +1,67 @@
+module Machines
+  module Commands
+    # The `Checks` module is used to execute a command to check whether the
+    # previous command was successful. These methods are useful when writing
+    # your own custom commands.
+    module Checks
+      def echo_result
+        '&& echo CHECK PASSED || echo CHECK FAILED'
+      end
+
+      def check_package package, exists = true
+        "dpkg --get-selections | grep #{package}.*#{exists ? '' : 'de'}install #{echo_result}"
+      end
+
+      def check_gem gem, version = nil
+        version = " -v #{version}" if version
+        "gem search #{gem}#{version} --installed #{echo_result}"
+      end
+
+      def check_file file, exists = true
+        "test #{exists ? '' : '! '}-s #{file} #{echo_result}"
+      end
+
+      def check_link link
+        "test -L #{link} #{echo_result}"
+      end
+
+      def check_dir dir, exists = true
+        "test #{exists ? '' : '! '}-d #{dir} #{echo_result}"
+      end
+
+      def check_perms perms, path
+        perms = perms.to_s
+        mods = %w(--- --x -w- -wx r-- r-x rw- rwx)
+        "ls -la #{path} | grep #{mods[perms[0..0].to_i]}#{mods[perms[1..1].to_i]}#{mods[perms[2..2].to_i]} #{echo_result}"
+      end
+
+      def check_owner user, path
+        "ls -la #{path} | grep \"#{user}.*#{user}\" #{echo_result}"
+      end
+
+      def check_string string, file
+        "grep \"#{string}\" #{file} #{echo_result}"
+      end
+
+      def check_daemon daemon, exists = true
+        command = 'ps aux'
+        search_for = "| grep #{daemon}"
+        remove_grep = '| grep -v grep'
+        negative = "| grep -v #{daemon} " unless exists
+        "#{command} #{search_for} #{remove_grep} #{negative}#{echo_result}"
+      end
+
+      def check_init_d name
+        "test -L /etc/rc0.d/K20#{name} #{echo_result}"
+      end
+
+      def check_command command, match = nil
+        if match
+          "#{command} | grep #{match} #{echo_result}"
+        else
+          "#{command} #{echo_result}"
+        end
+      end
+    end
+  end
+end

data/lib/machines/commands/configuration.rb

@@ -0,0 +1,50 @@
+module Machines
+  module Commands
+    module Configuration
+      # Add a new user
+      # (uses the lowlevel useradd so doesn't set a password unless specified)
+      # @param [String] login User name to create
+      # @param [Hash] options
+      # @option options [String] :password
+      # @option options [Boolean] :admin Adds the user to the admin group when true
+      def add_user login, options = {}
+        password = "-p #{`openssl passwd #{options[:password]}`.gsub("\n", '')} " if options[:password]
+        admin = "-G admin " if options[:admin]
+        Command.new(
+          "useradd -s /bin/bash -d /home/#{login} -m #{password}#{admin}#{login}",
+          check_dir("/home/#{login}")
+        )
+      end
+
+      # Add an existing user to a secondary group
+      # @param [Hash] options
+      # @option options [String] :user The user to add
+      # @option options [String] :to Adds an existing user to the specified group
+      def add options
+        required_options options, [:user, :to]
+        Command.new("usermod -a -G #{options[:to]} #{options[:user]}", check_command("groups #{options[:user]}", options[:to]))
+      end
+
+      # Sets gconf key value pairs
+      # @param [Hash] options One or many key/value pairs to set
+      def configure options
+        options.map do |key, value|
+          types = {String => 'string', Fixnum => 'int', TrueClass => 'bool',
+            FalseClass => 'bool', Float => 'float', Array => 'list --list-type=string'}
+          type = types[value.class]
+          raise 'Invalid type for configure' unless type
+          value = value.to_json if value.is_a?(Array)
+          value = %("#{value}") if type == 'string'
+          check = "gconftool-2 --get \"#{key}\" | grep #{value} #{echo_result}"
+          Command.new("gconftool-2 --set \"#{key}\" --type #{type} #{value}", check)
+        end
+      end
+
+      # Removes a user, home and any other related files
+      # @param [String] login User name to remove
+      def del_user login
+        Command.new("deluser #{login} --remove-home -q", check_file('/home/login', false))
+      end
+    end
+  end
+end

data/lib/machines/commands/database.rb

@@ -0,0 +1,18 @@
+module Machines
+  module Commands
+    module Database
+      # Write the database.yml file from webapps.yml
+      # @param [AppBuilder] app
+      def write_database_yml app
+        yml = {$conf.environment.to_s => {
+          'adapter' => 'mysql',
+          'database' => app.database || app.name,
+          'username' => app.username || app.name,
+          'password' => app.password,
+          'host' => $conf.db_server.address,
+          'encoding' => 'utf8'}}.to_yaml
+        write yml, :to => File.join(app.path, 'shared/config/database.yml'), :name => 'database.yml'
+      end
+    end
+  end
+end

data/lib/machines/commands/file_operations.rb

@@ -0,0 +1,105 @@
+module Machines
+  module Commands
+    module FileOperations
+      # Add a line of text to the end of a file unless it already exists
+      # @param [String] text Text to add
+      # @param [Hash] options
+      # @option options [String] :to File to append to
+      def append text, options
+        text = text.gsub(/([\\$"`])/, '\\\\\1')
+        Command.new("grep \"#{text}\" #{options[:to]} || echo \"#{text}\" >> #{options[:to]}", check_string(text, options[:to]))
+      end
+
+      # Change permissions of a path
+      # @param [String, Integer] mode chmod permissions to set
+      # @param [String] path Path to set
+      def chmod mode, path
+        Command.new("chmod #{mode} #{path}", check_perms(mode, path))
+      end
+
+      # Change ownership of a path
+      # @param [String] user sets user and group unless user:group is specified
+      # @param [String] path Path to set
+      # @param [Hash] options
+      # @option options [String] :recursive Chowns recursively if true
+      def chown user, path, options = {}
+        recursive = '-R ' if options[:recursive]
+        user = "#{user}:#{user}" unless user.index(':')
+        Command.new("chown #{recursive}#{user} #{path}", check_owner(user, path))
+      end
+
+      # Copy a remote file or folder (will overwrite)
+      # @param [String] from Existing path
+      # @param [String] to Path to copy to
+      def copy from, to
+        Command.new("cp -rf #{from} #{to}", check_file(to))
+      end
+
+      # Write a file from an ERB template
+      # @param [String] erb_path Path to the ERB file to process
+      # @param [Hash] options
+      # @option options [AppBuilder] :settings Contains the settings as OpenStruct method calls for calling from the template
+      # @option options [String] :to File to write to
+      def create_from erb_path, options
+        erb = ERB.new(File.read(erb_path), nil, '<>')
+        binding = options[:settings] ? options[:settings].get_binding : nil
+        options[:name] = erb_path
+        write erb.result(binding), options
+      end
+
+      # Add a symlink
+      # @param [String] target Existing path to link
+      # @param [String] link_name path name for the link
+      def link target, link_name
+        Command.new("ln -sf #{target} #{link_name}", check_link(link_name))
+      end
+
+      # Create a path or paths on the remote host (Uses -p to be safe and create full path)
+      # @param [String, Array] dirs A single path, multiple paths or array of paths to create
+      def mkdir *dirs
+        dirs.flatten.map do |dir|
+          Command.new("mkdir -p #{dir}", check_dir(dir))
+        end
+      end
+
+      # Rename a remote file or folder
+      # @param [String] oldname Existing filename
+      # @param [String] newname Rename to this
+      def rename oldname, newname
+        Command.new("mv -f #{oldname} #{newname}", check_file(newname))
+      end
+
+      # Remove a remote file or folder
+      # @param [String] file or folder to remove (uses rm with -rf which ignores non-existent files and is recursive)
+      def remove file
+        Command.new("rm -rf #{file}", check_file(file, false))
+      end
+
+      # Take off the version numbers from a path name
+      # @param [String] name Name of the path to rename
+      def remove_version_info name
+        Command.new("find . -maxdepth 1 -name \"#{name}*\" -a -type d | xargs -I xxx mv xxx #{name}", check_file(name))
+      end
+
+      # Replace some text in a file
+      # @param [String] regex The expression to search for
+      # @param [Hash] options
+      # @option options [String] :with Text to use as the replacement
+      # @option options [String] :in Filename to replace text in
+      def replace regex, options
+        required_options options, [:with, :in]
+        with = options[:with].gsub(/([\n\/\\$"`])/, '\\\\\1')
+        Command.new("sed -i \"s/#{regex}/#{with}/\" #{options[:in]}", check_string(with, options[:in]))
+      end
+
+      # (Over)write a file with the specified content
+      # @param [String] text Text to add
+      # @param [Hash] options
+      # @option options [String] :to File to write to
+      # @option options [String] :name Give the buffer a displayable name (e.g. when generated from a template)
+      def write text, options
+        Upload.new(NamedBuffer.new(options[:name], text), options[:to], check_string(text, options[:to]))
+      end
+    end
+  end
+end

data/lib/machines/commands/installation.rb

@@ -0,0 +1,184 @@
+module Machines
+  module Commands
+    module Installation
+      include Commands::FileOperations
+
+      APTGET_QUIET = 'apt-get -q -y'
+
+      # Adds a PPA source and updates apt
+      # @param [String] name Name of the PPA
+      # @param [String] key_name What to check in apt-key list to ensure it installed
+      # @example
+      #     add_ppa 'mozillateam/firefox-stable', 'mozilla'
+      def add_ppa name, key_name
+        [
+          Command.new("add-apt-repository ppa:#{name}", "apt-key list | grep -i #{key_name} #{echo_result}"),
+          update
+        ]
+      end
+
+      # Adds a DEB source
+      # @param [String] source URL of the package. If `YOUR_UBUNTU_VERSION_HERE` is included then it
+      #                 is replaced by the Ubuntu version name
+      # @param [Hash] options
+      # @option options [String] :key URL of key
+      # @option options [String] :name Used to check `apt-key list` to ensure it installed
+      # @example
+      #     sudo deb 'http://dl.google.com/linux/deb/ stable main',
+      #               key: 'https://dl-ssl.google.com/linux/linux_signing_key.pub',
+      #               name: 'Google'
+      def deb source, options
+        command = "echo deb #{source} >> /etc/apt/sources.list"
+        if source =~ /YOUR_UBUNTU_VERSION_HERE/
+          command = "expr substr `cat /etc/lsb-release | grep DISTRIB_CODENAME` 18 20 | xargs -I YOUR_UBUNTU_VERSION_HERE #{command}"
+        end
+        [
+          Command.new(command, check_string(source.gsub(/ .*$/, ''), '/etc/apt/sources.list')),
+          Command.new("wget -q #{options[:key]} -O - | apt-key add -", "apt-key list | grep -i #{options[:name]} #{echo_result}"),
+          update
+        ]
+      end
+
+      # Preseed debconf to allow silent installs
+      # @param [String] app Name of application to configure
+      # @param [String] setting The setting to set
+      # @param [String] type Data type of the value
+      # @param value The value to set (Ruby types supported)
+      def debconf app, setting, type, value
+        command = "echo #{app} #{setting} #{type} #{value} | debconf-set-selections"
+        check = "debconf-get-selections | grep #{app} #{echo_result}"
+        Command.new(command, check)
+      end
+
+      # Download, extract, and remove an archive. Currently supports `zip`, `tar.gz`, `tar.bz2`.
+      # @param [String] package Package name to extract
+      # @param [Hash] options
+      # @option options [Optional String] :to folder to clone or extract to (defaults to `/usr/local/src`)
+      # @example
+      #     sudo extract 'http://dl.suckless.org/dwm/dwm-6.0.tar.gz'
+      def extract package, options = {}
+        name = File.basename(package)
+        if package[/.zip/]
+          cmd = 'unzip -qq'
+        elsif package[/.tar.gz/]
+          cmd = 'tar -zxf'
+        elsif package[/.tar.bz2/]
+          cmd = 'tar -jxf'
+        else
+          raise "extract: Unknown extension for #{package}"
+        end
+        dir = cmd =~ /unzip/ ? File.basename(name, '.zip') : File.basename(name).gsub(/\.tar.*/, '')
+        dest = options[:to] || '/usr/local/src'
+        Command.new("cd #{dest} && wget #{package} && #{cmd} #{name} && rm #{name} && cd -", check_dir("#{File.join(dest, dir)}"))
+      end
+
+      # Install a gem
+      # @param [String] package Name of the gem
+      # @param [Hash] options
+      # @option options [String] :version Optional version number
+      def gem package, options = {}
+        version =  " -v \"#{options[:version]}\"" if options[:version]
+        Command.new("gem install #{package}#{version}", check_gem(package, options[:version]))
+      end
+
+      # Update gems
+      # @example Update Rubygems
+      #     gem_update '--system'
+      def gem_update options = ''
+        Command.new("gem update #{options}", nil)
+      end
+
+      # Clone (or update) a project from a Git repository
+      # @param [String] url URL to clone
+      # @param [Hash] options
+      # @option options [Optional String] :to Folder to clone to
+      # @option options [Optional String] :tag Checkout this tag after cloning (requires :to)
+      # @option options [Optional String] :branch Switch this branch when cloning
+      def git_clone url, options = {}
+        raise ArgumentError.new('git_clone Must include a url and folder') if url.nil? || url.empty?
+        raise ArgumentError.new('specifying :tag also requires :to') if options[:tag] && options[:to].nil?
+        branch = "--branch #{options[:branch]} " if options[:branch]
+        dir = options[:to] || url.gsub(/^.*\/|.git/, '')
+        command = "test -d #{dir} && (cd #{dir} && git pull) || git clone --quiet #{branch}#{url}"
+        command << " #{options[:to]}" if options[:to]
+        command = Command.new(command, check_dir(options[:to]))
+        command = [command, Command.new("cd #{options[:to]} && git checkout #{options[:tag]}", "git name-rev --name-only HEAD | grep #{options[:tag]}")] if options[:tag]
+        command
+      end
+
+      # Installs one or more packages using apt, deb or git clone and install.sh
+      # (See `extract` to just uncompress tar.gz or zip files).
+      # Packages are installed separately to aid progress feedback.
+      # Ensure this is the main package as dpkg get-selections is used to validate installation.
+      # @param [Symbol, String, Array] packages URL to download and install, string or array of apt packages
+      # @param [Hash] options
+      # @option options [Optional Symbol] :as Specify `:dpkg` to download URL and run `dpkg`
+      # @option options [Optional String] :bin Specify the bin file to link to (e.g. '/bin/executable'
+      #  will create a link /usr/local/bin/executable that points to /usr/local/lib/bin/executable)
+      # @option options [Optional Boolean] :make Set to true to run `sudo make clean install`
+      # @example Install apt packages
+      #     install %w(build-essential libssl-dev mysql-server)
+      # @example Download and install a deb using dpkg then remove the deb
+      #     install 'http://example.com/my_package.deb'
+      # @example Download and phantomjs to `/usr/local/lib` and add `bin/phantomjs` to `/usr/local/bin`
+      #     install 'http://phantomjs.googlecode.com/files/phantomjs-1.7.0-linux-x86_64.tar.bz2', bin: 'bin/phantomjs'
+      # @example Download dwm into `/usr/local/src/dwm-6.0` and install
+      #     install 'http://dl.suckless.org/dwm/dwm-6.0.tar.gz', make: true
+      def install packages, options = {}
+        if packages.is_a?(String)
+          if packages =~ /^http:\/\//
+            commands = []
+            if packages =~ /\.deb$/i
+              name = File.basename(packages)
+              commands << Command.new("cd /tmp && wget #{packages} && dpkg -i --force-architecture #{name} && rm #{name} && cd -", nil)
+            else
+              commands << extract(packages, :to => '/tmp')
+              name = File.basename(packages).gsub(/\.(tar|zip).*/, '')
+
+              if options[:as] == :dpkg
+                commands << Command.new("cd /tmp/#{name} && dpkg -i --force-architecture *.deb && cd - && rm -rf /tmp/#{name}", nil)
+              elsif options[:bin]
+                commands << rename("/tmp/#{name}", "/usr/local/lib")
+                commands << link("/usr/local/lib/#{name}/#{options[:bin]}", "/usr/local/bin/#{File.basename(options[:bin])}")
+              elsif options[:make]
+                commands << rename("/tmp/#{name}", "/usr/local/src")
+                commands << Command.new("cd /usr/local/src/#{name} && make clean install", nil)
+              end
+            end
+            return commands
+          else
+            packages = [packages]
+          end
+        end
+
+        if packages.is_a?(Array)
+          commands = packages.map do |package|
+            Command.new("#{APTGET_QUIET} install #{package}", check_package(package))
+          end
+        end
+        commands
+      end
+
+      # Remove one or more Ubuntu packages
+      # @param [Array] packages Packages to remove
+      def uninstall packages
+        packages.map do |package|
+          Command.new("#{APTGET_QUIET} purge #{package}", check_package(package, false))
+        end
+      end
+
+      # Updates Ubuntu packages
+      def update
+        Command.new("#{APTGET_QUIET} update > /tmp/apt-update.log", check_string('Reading package lists', '/tmp/apt-update.log'))
+      end
+
+      # Update, upgrade, autoremove, autoclean apt packages
+      def upgrade
+        # TODO: Check that check_command really checks the correct command with `echo $?`
+        %w(update upgrade autoremove autoclean).map do |command|
+          Command.new("#{APTGET_QUIET} #{command}", check_command('echo $?', '0'))
+        end
+      end
+    end
+  end
+end