lobot 2.1.0 → 3.0.0

data/lib/lobot/config.rb

@@ -1,212 +0,0 @@
-# encoding: UTF-8
-require "hashie"
-
-module Lobot
-  class Config < Hashie::Dash
-    property :path
-    property :aws_key
-    property :aws_secret
-    property :instance_id
-    property :master
-
-    property :instance_size, :default => 'c1.medium'
-    property :ssh_port, :default => 22
-    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', './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,
-        "cookbook_paths" => cookbook_paths,
-        "node_attributes" => node_attributes.to_hash
-      }
-    end
-
-    def save
-      return self unless path
-      File.open(path, "w+") { |file| file.write(YAML.dump(JSON.parse(JSON.dump(to_hash)))) }
-      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
-
-    def to_hash
-      hash = super
-      hash.delete("path")
-      {
-        "ssh_port" => ssh_port,
-        "master" => master,
-        "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 = {: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

@@ -1,117 +0,0 @@
-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

@@ -1,36 +0,0 @@
-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

@@ -1,13 +0,0 @@
-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,79 +0,0 @@
-require 'net/ssh'
-require 'shellwords'
-module Lobot
-  class Sobo
-    class CommandFailed < StandardError; end;
-
-    attr_reader :ip, :key, :user
-    attr_writer :timeout
-
-    def initialize(ip, key, user='ubuntu')
-      @ip = ip
-      @key = key
-      @user = user
-    end
-
-    def timeout
-      @timeout || 10000
-    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 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
-      ssh.loop
-      [stdout_data, stderr_data, exit_code, exit_signal]
-    end
-
-    def upload(from, to, opts = "--exclude .git")
-      Kernel.system(%Q{rsync --rsh="ssh -o 'StrictHostKeyChecking no' -i #{key}" --archive --compress --delete #{from} #{user}@#{ip}:#{to} #{opts}})
-    end
-  end
-end