machines 0.5.1

data/lib/machines/cloud_machine.rb

@@ -0,0 +1,33 @@
+module Machines
+  module CloudMachine
+    def connect_to_cloud
+      begin
+        require 'fog'
+      rescue LoadError
+        say 'fog gem required to use cloud features.'
+        say 'Please "gem install fog".'
+        raise
+      end
+
+      Fog.credential = 'machines_key'
+      options = symbolize_keys($conf.cloud.to_hash)
+      options.merge!(:region => $conf.machine.cloud.region)
+      $conf.cloud.connection = Fog::Compute.new(options)
+    end
+
+    def create_server
+      server = $conf.cloud.connection.servers.create(
+        :private_key_path => $conf.machine.cloud.private_key_path,
+        :public_key_path => $conf.machine.cloud.public_key_path,
+        :username => $conf.machine.cloud.username,
+        :flavor_id => $conf.machine.cloud.flavor_id,
+        :image_id => $conf.machine.cloud.image_id)
+      server.wait_for { ready? }
+    end
+
+    def symbolize_keys hash
+      hash.inject({}){|new_hash, (k, v)| new_hash[k.to_sym] = v; new_hash }
+    end
+  end
+end
+

data/lib/machines/command.rb

@@ -0,0 +1,86 @@
+require 'machines/logger'
+
+module Machines
+  class Command
+    class << self
+      attr_accessor :file, :debug, :console
+    end
+
+    attr_accessor :command, :check
+
+    def self.scp= scp
+      @@scp = scp
+    end
+
+    def self.ssh= ssh
+      @@ssh = ssh
+    end
+
+    def self.ssh
+      @@ssh
+    end
+
+    def self.scp
+      @@scp
+    end
+
+    def initialize(command, check)
+      @command = command
+      @check = check
+      @sudo = false
+    end
+
+    def use_sudo
+      @sudo = 'sudo'
+    end
+
+    def run
+      process {Command.file.log @@ssh.exec! wrap_in_export_and_sudo(@command)}
+    end
+
+    def info
+      ("%-6s " % (@sudo ? 'SUDO' : 'RUN')) + command
+    end
+
+  protected
+    def progress
+      "%3d%% " % (($conf.commands.index(self) + 1) / $conf.commands.count.to_f * 100).round
+    end
+
+    def process &block
+      Command.console.log progress + info, :newline => ($conf.log_only || false)
+      Command.file.log info, :color => :highlight
+      unless $conf.log_only
+        begin
+          yield
+          result = @@ssh.exec!(wrap_in_export_and_sudo(@check))
+          result = check_result(result || '')
+          color = color_for(result)
+          Command.file.log result, :color => color
+          Command.console.log progress + info, :color => color
+        rescue Exception => e
+          Command.console.log(progress + info, :color => :failure) rescue nil
+          Command.file.log(e.to_s, :color => :failure) rescue nil
+          raise e
+        end
+      end
+    end
+
+    def wrap_in_export_and_sudo command
+      command = "export TERM=linux && #{command}"
+      echo_password = "echo #{$conf.password} | " if $conf.password
+      command = "#{echo_password}sudo -S bash -c '#{command}'" if @sudo
+      Command.debug.log command
+      command
+    end
+
+    def check_result result
+      result.scan(/CHECK PASSED|CHECK FAILED/).first || 'NOT CHECKED'
+    end
+
+    def color_for result
+      {'NOT CHECKED' => :warning, 'CHECK FAILED' => :failure, 'CHECK PASSED' => :success}[result]
+    end
+  end
+end
+

data/lib/machines/commandline.rb

@@ -0,0 +1,148 @@
+module Machines
+  module Commandline
+    # Loads Machinesfile, opens an SCP connection and runs all commands and file uploads
+    def build options
+      $conf.machine_name = options.shift
+      $conf.task = options.shift
+      init
+      load_machinesfile
+
+      task $conf.task.to_sym if $conf.task
+
+      ssh_options = {:paranoid => false}
+      if $conf.machine.cloud
+        username = $conf.machine.cloud.username
+        ssh_options[:keys] = [$conf.machine.cloud.private_key_path]
+      else
+        username = $conf.machine.user
+        ssh_options[:password] = $conf.password
+      end
+
+      if $conf.log_only
+        $conf.commands.each do |command|
+          command.run
+        end
+      else
+        Kernel.trap("INT") { prepare_to_exit }
+        begin
+          Command.ssh = Net::SSH.start $conf.machine.address, username, ssh_options
+          Command.scp = Net::SCP.new(Command.ssh)
+          $conf.commands.each do |command|
+            command.run
+            Command.file.flush
+            exit if $exit_requested
+          end
+        ensure
+          Command.ssh.close
+        end
+      end
+    end
+
+    def dryrun options
+      $conf.log_only = true
+      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
+        confirm = ask "Overwrite '#{dir}' (y/n)? "
+        return unless confirm.downcase == 'y'
+      end
+      FileUtils.cp_r(File.join($conf.application_dir, 'template', '/.'), dir)
+      FileUtils.mkdir_p(File.join(dir, 'packages'))
+      say "Project created at #{dir}/"
+    end
+
+    def htpasswd options
+      path = File.join($conf.webserver, 'conf', 'htpasswd')
+      say "Generate BasicAuth password and add to #{path}"
+      username = ask('Username: ')
+      password = enter_password 'users'
+
+      crypted_pass = password.crypt(WEBrick::Utils.random_string(2))
+      FileUtils.mkdir_p File.dirname(path)
+      File.open(path, 'a') {|file| file.puts "#{username}:#{crypted_pass}" }
+      say "Password encrypted and added to #{path}"
+    end
+
+    def init
+      $exit_requested = false
+      $conf.passwords = []
+      $conf.commands = []
+      $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
+    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|
+        say " * #{File.basename(package, '.rb')}"
+      end
+      say ''
+
+      say 'Project packages'
+      Dir[File.join('packages', '**/*.rb')].each do |package|
+        say " * #{File.basename(package, '.rb')}"
+      end
+    end
+
+    def override package
+      package = package.first
+      destination = File.join('packages', "#{package}.rb")
+      answer = File.exists?(destination) ? ask('Project package already exists. Overwrite? (y/n)') : 'y'
+      if answer == 'y'
+        source = File.join($conf.application_dir, 'packages', "#{package}.rb")
+        FileUtils.cp(source, destination)
+        say "Package copied to #{destination}"
+      else
+        say 'Aborted.'
+      end
+    end
+
+    def tasks
+      $conf.log_only = true
+      init
+      load_machinesfile
+      say 'Tasks'
+      $conf.tasks.each do |task_name, settings|
+        say "  %-20s #{settings[:description]}" % task_name
+      end
+    end
+
+  private
+    def prepare_to_exit
+      exit if $exit_requested
+      $exit_requested = true
+      Command.console.log("\nEXITING after current command completes...", :color => :warning)
+      Command.console.log("(Press again to terminate immediately)...", :color => :warning)
+    end
+  end
+end
+

data/lib/machines/configuration.rb

@@ -0,0 +1,49 @@
+module Machines
+  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
+

data/lib/machines/core.rb

@@ -0,0 +1,117 @@
+module Machines
+  module Core
+    # If a block is given, store the task, log it and run it
+    # If no block is given, sets commands to only those of the specified task so they can be run standalone
+    # @param [Symbol] name Name of the task
+    # @param [String] description Describe the task
+    # @param [Hash] options
+    # @option options [Symbol, Array] :if Dependent tasks that must already have been added for this task to be added
+    def task name, description = nil, options = {}, &block
+      if block
+        dependencies = [options[:if]].flatten
+        return if options[:if] && (dependencies - $conf.tasks.keys).any?
+        store_task name, description, &block
+        $conf.commands << LogCommand.new(name, description)
+        yield
+      else
+        $conf.commands = []
+        $conf.tasks[name][:block].call
+      end
+    end
+
+    def store_task name, description, &block
+      $conf.tasks[name] = {:description => description, :block => block}
+    end
+
+    def list_tasks
+      $conf.tasks.each do |name, task|
+        say "  #{"%-20s" % name}#{task[:description]}"
+      end
+    end
+
+    def generate_password
+      WEBrick::Utils.random_string(20)
+    end
+
+    # Only executes the code if $conf parameters match what is given in args
+    def only options, &block
+      yield if matched(options)
+    end
+
+    # Does not execute the code if $conf parameters match what is given in args
+    def except options, &block
+      yield unless matched(options)
+    end
+
+    def matched options
+      options.each do |key, value|
+        value = value.is_a?(Array) ? value.map{|o| o.to_s } : value.to_s
+        if $conf[key].is_a?(Array)
+          values = $conf[key].map{|o| o.to_s }
+          if value.is_a?(Array)
+            return unless values.reject{ |symbol| !value.include?(symbol.to_s) }.any?
+          else
+            return unless values.include?(value)
+          end
+        else
+          if value.is_a?(Array)
+            return unless value.include?($conf[key].to_s)
+          else
+            return unless value == $conf[key].to_s
+          end
+        end
+      end
+      true
+    end
+
+    # Queue up command(s) to run remotely
+    # @param [Array] commands Command(s) to run.
+    # If first command is a string it creates a Command object using the first two strings as command and check
+    def run *commands
+      commands = command_from_string(commands)
+      $conf.commands += commands.flatten
+    end
+
+    # Queue up command(s) using SUDO to run remotely
+    # @param [Array] commands Command(s) to run
+    def sudo *commands
+      commands = command_from_string commands
+      commands.flatten.each do |command|
+        if command.is_a?(Upload)
+          temp_path = "/tmp/#{File.basename(command.remote)}"
+          dir_suffix = command.local.is_a?(String) && File.directory?(command.local) ? '/.' : ''
+          remote_dest = command.remote
+          command.remote = temp_path
+          command.check = check_file(temp_path)
+          run command
+          sudo copy(temp_path + dir_suffix, remote_dest)
+          run remove temp_path
+        else
+          command.use_sudo
+          run command
+        end
+      end
+    end
+
+    # Upload a file or folder using SCP
+    # Can be used with sudo or run
+    # @param [String] local_source File or folder on the local machine
+    # @param [String] remote_dest Folder on the remote machine to copy to
+    #     upload 'source_dir', '~' #=> creates source_dir/subdir as ~/subdir
+    def upload local_source, remote_dest
+      Upload.new(local_source, remote_dest, check_file(remote_dest))
+    end
+
+    # Validate some methods that require certain options
+    def required_options options, required
+      required.each do |option|
+        raise ArgumentError, "Missing option '#{option}'. Check trace for location of the problem." unless options[option]
+      end
+    end
+
+    def command_from_string commands
+      commands.first.is_a?(String) ? [Command.new(commands[0], commands[1])] : commands
+    end
+  end
+end
+

data/lib/machines/database.rb

@@ -0,0 +1,17 @@
+module Machines
+  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
+

data/lib/machines/file_operations.rb

@@ -0,0 +1,104 @@
+module Machines
+  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
+

data/lib/machines/help.rb

@@ -0,0 +1,30 @@
+module Machines
+  class Help
+    def initialize
+      @actions = {
+        'htpasswd' => 'Generates basic auth in webserver/conf/htpasswd',
+        'new <DIR>' => 'Generates an example machines project in DIR',
+        'dryrun <machine>' => 'Logs commands but does not run them',
+        'tasks' => 'Lists the available tasks',
+        'build <machine> [task]' => 'Builds your chosen machine. Optionally, build just one task',
+        'list' => 'Lists the available machines',
+        'packages' => 'Lists the available packages',
+        'override <PACKAGE>' => 'Copies the default package into project/packages so it can be edited/overidden'
+      }
+    end
+
+    def actions
+      @actions.keys.map{|key| key.gsub(/ .*/, '')}
+    end
+
+    def syntax
+      <<HELP
+machines v#{Machines::VERSION} - Ubuntu/Ruby configuration tool.
+machines COMMAND
+COMMAND can be:
+#{@actions.map{|action, help| "  %-25s#{help}" % action}.join("\n")}
+HELP
+    end
+  end
+end
+