lobot 2.0.0pre → 2.1.0

data/lib/lobot/config.rb

@@ -1,3 +1,4 @@
+# encoding: UTF-8
 require "hashie"
 
 module Lobot
@@ -10,33 +11,98 @@ module Lobot
 
     property :instance_size, :default => 'c1.medium'
     property :ssh_port, :default => 22
-    property :server_ssh_key, :default => File.expand_path("~/.ssh/id_rsa")
-    property :github_ssh_key, :default => File.expand_path("~/.ssh/id_rsa")
+    property :server_ssh_key, :default => Proc.new { default_ssh_key }
+    property :github_ssh_key, :default => Proc.new { default_ssh_key }
     property :recipes, :default => ["pivotal_ci::jenkins", "pivotal_ci::limited_travis_ci_environment", "pivotal_ci"]
-    property :cookbook_paths, :default => ['./chef/cookbooks/', './chef/travis-cookbooks/ci_environment']
-    property :node_attributes, :default => {
-      :travis_build_environment => {
-        :user => "jenkins",
-        :group => "nogroup",
-        :home => "/var/lib/jenkins"
-      },
-      :nginx => {
-        :basic_auth_user => "ci",
-      },
-      :jenkins => {
-        :builds => []
-      }
-    }
+    property :cookbook_paths, :default => ['./chef/cookbooks/', './chef/travis-cookbooks/ci_environment', './chef/project-cookbooks']
+    property :node_attributes, :default => Proc.new { default_node_attributes }
 
     def initialize(attributes = {})
       super
       self["node_attributes"] = Hashie::Mash.new(node_attributes)
     end
 
+    def add_build(name, repository, branch, command)
+      build = {
+        "name" => name,
+        "repository" => repository,
+        "branch" => branch,
+        "command" => command,
+        "junit_publisher" => true
+      }
+      self.node_attributes = self.node_attributes.tap do |config|
+        config.jenkins.builds << build unless config.jenkins.builds.include?(build)
+      end
+    end
+
+    def github_ssh_key_path
+      File.expand_path(self["github_ssh_key"]) if self["github_ssh_key"]
+    end
+
+    def github_ssh_pubkey_path
+      github_ssh_key_path + ".pub" if self["github_ssh_key"]
+    end
+
+    def github_ssh_key
+      File.read(github_ssh_key_path)
+    end
+
+    def github_ssh_pubkey
+      File.read(github_ssh_pubkey_path)
+    end
+
+    def server_ssh_key_path
+      File.expand_path(self["server_ssh_key"]) if self["server_ssh_key"]
+    end
+
+    def server_ssh_pubkey_path
+      server_ssh_key_path + ".pub" if self["server_ssh_key"]
+    end
+
+    def server_ssh_key
+      File.read(server_ssh_key_path)
+    end
+
+    def server_ssh_pubkey
+      File.read(server_ssh_pubkey_path)
+    end
+
+    def master_url
+      "https://#{master}" if master
+    end
+
+    def jenkins_url
+      "https://#{CGI.escape(basic_auth_user)}:#{CGI.escape(basic_auth_password)}@#{master}" if master
+    end
+
+    def cc_menu_url
+      "#{jenkins_url}/cc.xml" if master
+    end
+
+    def rss_url(job_name)
+      master_url + "/job/#{job_name}/rssAll" if master_url
+    end
+
     def node_attributes=(attributes)
       self["node_attributes"] = Hashie::Mash.new(attributes)
     end
 
+    def valid?
+      errors.empty?
+    end
+
+    def errors
+      messages = []
+      if node_attributes.has_key?("jenkins")
+        unless node_attributes.jenkins.has_key?("builds")
+          messages << "[:node_attributes][:jenkins][:builds]"
+        end
+      else
+        messages << "[:node_attributes][:jenkins]"
+      end
+      messages.map{ |path| "your config file does not have a #{path} key" }
+    end
+
     def soloistrc
       {
         "recipes" => recipes,
@@ -51,6 +117,13 @@ module Lobot
       self
     end
 
+    def update(options = {})
+      options.each_pair do |attr, value|
+        self.send("#{attr}=", value)
+      end
+      save
+    end
+
     def reload
       self.class.from_file(path)
     end
@@ -61,20 +134,79 @@ module Lobot
       {
         "ssh_port" => ssh_port,
         "master" => master,
-        "server_ssh_key" => server_ssh_key,
+        "server_ssh_key" => server_ssh_key_path,
         "recipes" => recipes,
         "cookbook_paths" => cookbook_paths,
         "node_attributes" => node_attributes
       }.merge(hash)
     end
 
+    def display
+      <<OOTPÜT.gsub(/(\S)\s+$/, '\1').gsub(/^\./, '')
+-- ciborg configuration --
+  Instance ID:        #{instance_id}
+  IP Address:         #{master}
+  Instance size:      #{instance_size}
+.
+  Builds:
+#{builds}
+.
+  Web URL:            #{master_url}
+  User name:          #{basic_auth_user}
+  User password:      #{basic_auth_password}
+.
+  CC Menu URL:        #{cc_menu_url}
+.
+OOTPÜT
+    end
+
     def self.from_file(yaml_file)
-      config = read_config(yaml_file)
-      self.new(config.merge(:path => yaml_file))
+      config = {:path => yaml_file}
+      config.merge!(read_config(yaml_file)) if File.exists?(yaml_file)
+      config.delete('keypair_name')
+      self.new(config)
     end
 
     def self.read_config(yaml_file)
       File.open(yaml_file, "r") { |file| YAML.load(file.read) }
     end
+
+    def basic_auth_user
+      node_attributes[:nginx][:basic_auth_user]
+    end
+
+    def basic_auth_password
+      node_attributes[:nginx][:basic_auth_password]
+    end
+
+    def builds
+      node_attributes[:jenkins][:builds].
+        map { |build| build[:name] }    .
+        map { |build| "    %-17s %s" % [build, rss_url(build)] }  .
+        join("\n")
+    end
+
+    private
+
+    def self.default_ssh_key
+      "~/.ssh/id_rsa" if File.exists?(File.expand_path("~/.ssh/id_rsa"))
+    end
+
+    def self.default_node_attributes
+      {
+        :travis_build_environment => {
+          :user => "jenkins",
+          :group => "nogroup",
+          :home => "/var/lib/jenkins"
+        },
+        :nginx => {
+          :basic_auth_user => "ci",
+          :basic_auth_password => Lobot::Password.generate
+        },
+        :jenkins => {
+          :builds => []
+        }
+      }
+    end
   end
 end

data/lib/lobot/configuration_wizard.rb

@@ -0,0 +1,117 @@
+require "thor"
+
+module Lobot
+  class ConfigurationWizard < ::Thor
+    include Actions
+
+    DESCRIPTION_TEXT = "Sets up lobot through a series of questions"
+
+    default_task :setup
+
+    desc "setup", DESCRIPTION_TEXT
+    def setup
+      return unless yes?("It looks like you're trying to set up a CI Box. Can I help? (Yes/No)")
+      prompt_for_build
+      prompt_for_github_key
+      prompt_for_ssh_key
+      prompt_for_aws
+      prompt_for_basic_auth
+      config.save
+      say config.reload.display
+      if user_wants_to_create_instance?
+        create_instance
+        provision_server
+      end
+    end
+
+    no_tasks do
+      def ask_with_default(statement, default)
+        question = default ? "#{statement} [#{default}]:" : "#{statement}:"
+        answer = ask(question) || ""
+        answer.empty? ? default : answer
+      end
+
+      def prompt_for_aws
+        say("For your AWS Access Key and Secret, see https://aws-portal.amazon.com/gp/aws/developer/account/index.html?ie=UTF8&action=access-key")
+        config.aws_key = ask_with_default("Your AWS key", config.aws_key)
+        config.aws_secret = ask_with_default("Your AWS secret key", config.aws_secret)
+      end
+
+      def prompt_for_basic_auth
+        config.node_attributes.nginx.basic_auth_user = ask_with_default("Your CI username", config.node_attributes.nginx.basic_auth_user)
+        config.node_attributes.nginx.basic_auth_password = ask_with_default("Your CI password", config.node_attributes.nginx.basic_auth_password)
+      end
+
+      def prompt_for_ssh_key
+        config.server_ssh_key = ask_with_default("Path to CI server SSH key", config.server_ssh_key_path)
+      end
+
+      def prompt_for_github_key
+        config.github_ssh_key = ask_with_default("Path to a SSH key authorized to clone the repository", config.github_ssh_key_path)
+      end
+
+      def prompt_for_build
+        build = config.node_attributes.jenkins.builds.first || {}
+
+        if this_is_a_rails_project? && prompt_for_default_rails_script
+          build_command = Proc.new { "script/ci_build.sh" }
+          copy_file('default_rails_build_script.sh', 'script/ci_build.sh')
+        else
+          build_command = Proc.new { ask_with_default("What command should be run during the build?", build["command"]) }
+        end
+
+        repository = ask_with_default("What is the address of your git repository?", build["repository"])
+        name = ask_with_default("What would you like to name your build?", build["name"])
+        command = build_command.call
+        branch = "master"
+
+        config.add_build name, repository, branch, command
+      end
+
+      def user_wants_to_create_instance?
+        return unless config.master.nil?
+        yes?("Would you like to start an instance on AWS now? (Yes/No)")
+      end
+
+      def create_instance
+        say("Creating instance #{config.instance_size}")
+        cli.create
+        say("Instance launched.")
+      end
+
+      def provision_server
+        return if config.reload.master.nil?
+        cli.bootstrap
+        cli.chef
+      end
+
+      def config
+        @config ||= Lobot::Config.from_file(lobot_config_path)
+      end
+    end
+
+    private
+
+    def source_paths
+      [File.join(File.expand_path(File.dirname(__FILE__)), "templates")] + super
+    end
+
+    def prompt_for_default_rails_script
+      return false if File.exists?('script/ci_build.sh')
+      yes?("It looks like this is a Rails project.  Would you like to use the default Rails build script? (Yes/No)")
+    end
+
+    def this_is_a_rails_project?
+      File.exists?('script/rails')
+    end
+
+    def lobot_config_path
+      FileUtils.mkdir_p(File.join(Dir.pwd, "config"))
+      File.expand_path("config/lobot.yml", Dir.pwd)
+    end
+
+    def cli
+      Lobot::CLI.new
+    end
+  end
+end

data/lib/lobot/keychain.rb

@@ -0,0 +1,36 @@
+require "httpclient"
+
+module Lobot
+  class Keychain
+    attr_reader :config, :path
+
+    def initialize(keychain_path)
+      @path = keychain_path
+    end
+
+    def has_key?(key_name)
+      system("sudo security find-certificate -c \"#{key_name}\" #{path} > /dev/null 2>&1")
+    end
+
+    def fetch_remote_certificate(host)
+      http_client.get(host).peer_cert.to_s
+    end
+
+    def add_certificate(certificate)
+      certificate_file = Tempfile.new("lobot.crt").tap do |f|
+        f.write(certificate)
+        f.close
+      end
+
+      system("sudo security add-trusted-cert -d -r trustAsRoot -k /Library/Keychains/System.keychain #{certificate_file.path}")
+    end
+
+    private
+    def http_client
+      @http_client ||=
+        HTTPClient.new.tap do |hc|
+          hc.ssl_config.verify_mode = OpenSSL::SSL::VERIFY_NONE
+        end
+    end
+  end
+end

data/lib/lobot/password.rb

@@ -0,0 +1,13 @@
+require "haddock"
+
+module Lobot
+  class Password
+    class << self
+      def generate
+        Haddock::Password.generate
+      rescue Haddock::Password::NoWordsError
+        return ""
+      end
+    end
+  end
+end

data/lib/lobot/sobo.rb

@@ -1,35 +1,79 @@
 require 'net/ssh'
-
+require 'shellwords'
 module Lobot
   class Sobo
-    attr_reader :ip, :key
+    class CommandFailed < StandardError; end;
+
+    attr_reader :ip, :key, :user
     attr_writer :timeout
 
-    def initialize(ip, key)
+    def initialize(ip, key, user='ubuntu')
       @ip = ip
       @key = key
+      @user = user
     end
 
     def timeout
       @timeout || 10000
     end
 
-    def exec(command)
-      Net::SSH.start(ip, "ubuntu", :keys => [key], :timeout => timeout) do |ssh|
-        ssh.exec(command)
-      end
+    def system(command)
+      ssh_popen4!(command, true)[2]
+    end
+
+    def system!(command)
+      result = ssh_popen4!(command, true)
+      raise(CommandFailed, "Failed: #{command}\n#{result[0]}\n\n#{result[1]}") unless result[2] == 0
+    end
+
+    def backtick(command)
+      ssh_popen4!(command)[0]
     end
 
-    def exec!(command)
-      output = nil
-      Net::SSH.start(ip, "ubuntu", :keys => [key], :timeout => timeout) do |ssh|
-        output = ssh.exec!(command)
+    def ssh_popen4!(command, streaming_output = false)
+      ssh = Net::SSH.start(ip, user, :keys => [key], :timeout => timeout, paranoid: false)
+      stdout_data = ""
+      stderr_data = ""
+      exit_code = nil
+      exit_signal = nil
+
+      ssh.open_channel do |channel|
+        channel.exec("/bin/bash -lc #{Shellwords.escape(command)}") do |ch, success|
+          unless success
+            raise "FAILED: couldn't execute command (ssh.channel.exec)"
+          end
+
+          channel.on_data do |ch,data|
+            if streaming_output
+              STDOUT << data
+              STDOUT.flush
+            end
+            stdout_data += data
+          end
+
+          channel.on_extended_data do |ch,type,data|
+            if streaming_output
+              STDERR << data
+              STDERR.flush
+            end
+            stderr_data += data
+          end
+
+          channel.on_request("exit-status") do |ch,data|
+            exit_code = data.read_long
+          end
+
+          channel.on_request("exit-signal") do |ch, data|
+            exit_signal = data.read_long
+          end
+        end
       end
-      output
+      ssh.loop
+      [stdout_data, stderr_data, exit_code, exit_signal]
     end
 
     def upload(from, to, opts = "--exclude .git")
-      system("rsync -avz --delete #{from} ubuntu@#{ip}:#{to} #{opts}")
+      Kernel.system(%Q{rsync --rsh="ssh -o 'StrictHostKeyChecking no' -i #{key}" --archive --compress --delete #{from} #{user}@#{ip}:#{to} #{opts}})
     end
   end
 end