conjure 0.2.10 → 0.3.0

data/lib/conjure/command_target.rb

@@ -1,25 +0,0 @@
-module Conjure
-  class CommandTarget
-    def initialize(options = {})
-      @origin = options[:origin]
-      @branch = options[:branch] || "master"
-      @rails_env = options[:rails_env] || "production"
-    end
-
-    def application
-      @application ||= Application.find(:path => Dir.pwd, :origin => @origin)
-    end
-
-    def existing_instance
-      @existing_instance ||= application.instances.first
-    end
-
-    def new_instance
-      @new_instance ||= Instance.new(
-        :origin => application.origin,
-        :branch => @branch,
-        :rails_environment => @rails_env,
-      )
-    end
-  end
-end

data/lib/conjure/config.rb

@@ -1,44 +0,0 @@
-module Conjure
-  class Config
-    def self.load(root_path)
-      require "ostruct"
-      config_path = File.join root_path, "config", "conjure.yml"
-      if File.exists? config_path
-        data = YAML.load_file config_path
-        data["config_path"] = File.dirname config_path
-      else
-        data = {}
-      end
-      new data
-    end
-
-    def initialize(options)
-      @options = options
-      find_default_keys unless @options["private_key"]
-    end
-
-    def method_missing(name)
-      @options[name.to_s]
-    end
-
-    def file_contents(name)
-      name = @options[name.to_s] if name.is_a? Symbol
-      name = File.join(@options["config_path"], name) unless name[0] == "/"
-      File.open name, "rb", &:read
-    end
-
-    private
-
-    def find_default_keys
-      private_key_paths = ["~/.ssh/id_rsa", "~/.ssh/id_dsa", "~/.ssh/identity"]
-      private_key_paths.each do |path|
-        path = File.expand_path(path)
-        if File.exists?(path) and File.exists?("#{path}.pub")
-          @options["private_key_file"] = path
-          @options["public_key_file"] = "#{path}.pub"
-          return
-        end
-      end
-    end
-  end
-end

data/lib/conjure/data_set.rb

@@ -1,7 +0,0 @@
-module Conjure
-  class DataSet
-    def self.find(options = {})
-      []
-    end
-  end
-end

data/lib/conjure/identity.rb

@@ -1,25 +0,0 @@
-module Conjure
-  class Identity
-    require "digest/md5"
-
-    def initialize(config)
-      @config = config
-    end
-
-    def private_key_path
-      Pathname.new(@config.config_path).join @config.private_key_file
-    end
-
-    def public_key_path
-      Pathname.new(@config.config_path).join @config.public_key_file
-    end
-
-    def public_key_data
-      File.open(public_key_path, "rb") { |file| file.read }
-    end
-
-    def unique_identifier
-      "conjure_#{Digest::MD5.hexdigest(public_key_data)[0..7]}"
-    end
-  end
-end

data/lib/conjure/log.rb

@@ -1,26 +0,0 @@
-module Conjure
-  class Log
-    class << self
-      attr_accessor :level
-      attr_accessor :capture
-      attr_reader :history
-    end
-
-    def self.info(message)
-      if @capture
-        @history ||= ""
-        @history << "#{message}\n"
-      else
-        puts message
-      end
-    end
-
-    def self.debug(message)
-      info message if @level == :debug
-    end
-
-    def self.clear
-      @history = ""
-    end
-  end
-end

data/lib/conjure/provider.rb

@@ -1,26 +0,0 @@
-module Conjure
-  module Provider
-    def self.included(base)
-      base.extend ClassMethods
-    end
-
-    def self.all(service_type)
-      providers(service_type).map{|block| block.call}.flatten.compact
-    end
-
-    def self.register_provider(service_type, &block)
-      providers(service_type) << block
-    end
-
-    def self.providers(service_type)
-      @providers ||= {}
-      @providers[service_type] ||= []
-    end
-
-    module ClassMethods
-      def provides(service_type, &block)
-        Conjure::Provider.register_provider(service_type, &block)
-      end
-    end
-  end
-end

data/lib/conjure/provision.rb

@@ -1 +0,0 @@
-require "conjure/provision/instance"

data/lib/conjure/provision/docker/host.rb

@@ -1,32 +0,0 @@
-module Conjure
-  module Provision
-    module Docker
-      class Host
-        def initialize(platform)
-          @platform = platform
-        end
-
-        def built_image_name(dockerfile_directory)
-          result = @platform.with_directory(dockerfile_directory) do |remote_dir|
-            @platform.run "docker build #{remote_dir}"
-          end
-          if match = result.match(/Successfully built ([0-9a-z]+)/)
-            match[1]
-          else
-            raise "Failed to build Docker image, output was #{result}"
-          end
-        end
-
-        def started_container_id(image_name, daemon_command, run_options = nil)
-          all_options = "#{run_options.to_s} #{image_name} #{daemon_command}"
-          @platform.run("docker run #{all_options}").strip
-        end
-
-        def container_ip_address(container_id)
-          format = "{{ .NetworkSettings.IPAddress }}"
-          @platform.run("docker inspect --format '#{format}' #{container_id}").strip
-        end
-      end
-    end
-  end
-end

data/lib/conjure/provision/docker/image.rb

@@ -1,55 +0,0 @@
-module Conjure
-  module Provision
-    module Docker
-      class Image
-        attr_reader :image_name
-
-        def initialize(docker_host, image_name)
-          @docker_host = docker_host
-          @name = image_name
-        end
-
-        def start_volume(options = {})
-          @docker_host.started_container_id @name, "/bin/true", daemon_options(options)
-        end
-
-        def start_daemon(command, options = {})
-          container_id = @docker_host.started_container_id @name, command, daemon_options(options)
-          sleep 2
-          ip_address = @docker_host.container_ip_address container_id
-          raise "Container failed to start" unless ip_address.present?
-          ip_address
-        end
-
-        private
-
-        def volume_options(options)
-          "-d " + run_options(options)
-        end
-
-        def daemon_options(options)
-          "-d --restart=always " + run_options(options)
-        end
-
-        def run_options(options)
-          [
-            mapped_options("--link", options[:linked_containers]),
-            ("--name #{options[:name]}" if options[:name]),
-            mapped_options("-p", options[:ports]),
-            listed_options("--volumes-from", options[:volume_containers]),
-          ].flatten.compact.join(" ")
-        end
-
-        def listed_options(command, values)
-          values ||= []
-          values.map { |v| "#{command} #{v}" }
-        end
-
-        def mapped_options(command, values)
-          values ||= {}
-          values.map { |from, to| "#{command} #{from}:#{to}" }
-        end
-      end
-    end
-  end
-end

data/lib/conjure/provision/docker/template.rb

@@ -1,55 +0,0 @@
-require "conjure/provision/docker/host"
-require "conjure/provision/docker/image"
-require "tmpdir"
-
-module Conjure
-  module Provision
-    module Docker
-      class Template
-        def initialize(base_image_name)
-          @commands = ["FROM #{base_image_name}"]
-          @file_data = {}
-        end
-
-        def add_file(filename, remote_name)
-          add_file_data File.read(filename), remote_name
-        end
-
-        def add_file_data(data, remote_name)
-          local_name = "file#{@file_data.length+1}"
-          @file_data[local_name] = data
-          @commands << "ADD #{local_name} #{remote_name}"
-        end
-
-        def run(command)
-          @commands << "RUN #{command}"
-        end
-
-        def volume(name)
-          @commands << "VOLUME #{name}"
-        end
-
-        def source
-          @commands.join "\n"
-        end
-
-        def prepare_build_directory(&block)
-          Dir.mktmpdir do |dir|
-            @file_data.merge("Dockerfile" => source).each do |filename, data|
-              File.write "#{dir}/#{filename}", data
-            end
-            yield dir
-          end
-        end
-
-        def build(platform)
-          docker_host = Host.new(platform)
-          image_name = prepare_build_directory do |dir|
-            docker_host.built_image_name dir
-          end
-          Image.new docker_host, image_name
-        end
-      end
-    end
-  end
-end

data/lib/conjure/provision/instance.rb

@@ -1,52 +0,0 @@
-require "conjure/provision/docker/template"
-require "conjure/provision/local_docker"
-require "conjure/provision/server"
-require "conjure/provision/postgres"
-require "conjure/provision/passenger"
-require "yaml"
-
-module Conjure
-  module Provision
-    class Instance
-      def initialize(app_name, rails_env, options = {})
-        @app_name = app_name
-        @rails_env = rails_env
-        @options = options
-      end
-
-      def provision(options = {})
-        if options[:local]
-          platform = LocalDocker.new
-        else
-          platform = Server.create "#{@app_name}-#{@rails_env}", @options
-        end
-
-        database = Postgres.new(platform)
-        database.start
-
-        webserver = Passenger.new(platform, database, @rails_env, @options)
-        webserver.start
-        passenger_ip = webserver.ip_address
-
-        port = platform.ip_address ? "2222" : "22"
-        ip_address = platform.ip_address || passenger_ip
-
-        host = "root@#{ip_address} -p #{port}"
-
-        sleep 1
-        remote_command host, "/etc/init.d/nginx restart"
-        {
-          :ip_address => ip_address,
-          :port => port,
-          :user => "app",
-          :rails_env => @rails_env,
-          :pending_files => webserver.pending_files,
-        }
-      end
-
-      def remote_command(host, command)
-        `ssh -o UserKnownHostsFile=/dev/null -o StrictHostKeyChecking=no #{host} #{command}`
-      end
-    end
-  end
-end

data/lib/conjure/provision/local_docker.rb

@@ -1,16 +0,0 @@
-module Conjure
-  module Provision
-    class LocalDocker
-      def run(command)
-        `#{command}`
-      end
-
-      def with_directory(path)
-        yield path
-      end
-
-      def ip_address
-      end
-    end
-  end
-end

data/lib/conjure/provision/passenger.rb

@@ -1,111 +0,0 @@
-require "conjure/provision/docker/template"
-require "securerandom"
-
-module Conjure
-  module Provision
-    class Passenger
-      attr_reader :ip_address
-
-      def initialize(platform, database, rails_env, options)
-        @platform = platform
-        @database = database
-        @rails_env = rails_env
-        @nginx_directives = options[:nginx_directives] || {}
-        @system_packages = options[:system_packages] || []
-        @rubygems_version = options[:rubygems_version]
-        @use_ssl = !!options[:ssl_hostname]
-        @ssl_hostname = options[:ssl_hostname] || "unknown"
-      end
-
-      def start 
-        @ip_address = server_template.build(@platform).start_daemon("/sbin/my_init", start_options)
-      end
-
-      def pending_files
-        return [] unless @use_ssl
-        [
-          "/etc/ssl/certs/application.crt",
-          "/etc/ssl/certs/root_and_intermediates.crt",
-          "/etc/ssl/private/application.key",
-          "/etc/ssl/dhparam.pem",
-        ]
-      end
-
-      private
-
-      def start_options
-        {
-          :linked_containers => @database.container_link,
-          :name => "passenger",
-          :ports => {80 => 80, 443 => 443, 2222 => 22},
-          :volume_containers => [data_container_name],
-        }
-      end
-
-      def data_container_name
-        data_template.build(@platform).start_volume(:name => "passenger_data")
-        "passenger_data"
-      end
-
-      def data_template
-        file = Docker::Template.new("conjure/passenger-ruby22:1.0.0")
-        file.add_file_data database_yml, "/home/app/application/shared/config/database.yml"
-        file.add_file_data secrets_yml, "/home/app/application/shared/config/secrets.yml"
-        file.volume "/home/app/application"
-        file
-      end
-
-      def server_template
-        public_key = File.expand_path("~/.ssh/id_rsa.pub")
-        raise "Error: ~/.ssh/id_rsa.pub must exist." unless File.exist?(public_key)
-        file = Docker::Template.new("conjure/passenger-ruby22:1.0.1")
-        file.run apt_command if apt_command
-        file.run rubygems_command if rubygems_command
-        file.add_file public_key, "/root/.ssh/authorized_keys"
-        file.add_file public_key, "/home/app/.ssh/authorized_keys"
-        file.run "chown app.app /home/app/.ssh/authorized_keys"
-        file.run "chown root.root /root/.ssh/authorized_keys"
-        file.add_file_data nginx_conf, "/etc/nginx/sites-available/application-no-ssl.conf"
-        file.add_file_data nginx_ssl_conf, "/etc/nginx/sites-available/application-ssl.conf"
-        which_config = @use_ssl ? "application-ssl" : "application-no-ssl"
-        file.run "ln -s /etc/nginx/sites-available/#{which_config}.conf /etc/nginx/sites-enabled/application.conf"
-        file
-      end
-
-      def apt_command
-        if @system_packages.any?
-          "apt-get update && apt-get install -y #{@system_packages.join ' '}"
-        end
-      end
-
-      def rubygems_command
-        if @rubygems_version
-          target_source = "/usr/lib/ruby/vendor_ruby/rubygems/defaults/operating_system.rb"
-          "sed -i '23d' #{target_source} && gem update --system #{@rubygems_version}"
-        end
-      end
-
-      def database_yml
-        {@rails_env => @database.rails_config}.to_yaml
-      end
-
-      def secrets_yml
-        {@rails_env => {"secret_key_base" => SecureRandom.hex(64)}}.to_yaml
-      end
-
-      def nginx_conf
-        render_template "application-no-ssl.conf"
-      end
-
-      def nginx_ssl_conf
-        render_template "application-ssl.conf"
-      end
-
-      def render_template(name)
-        template_path = File.join File.dirname(__FILE__), "templates", "#{name}.erb"
-        template_data = File.read template_path
-        Erubis::Eruby.new(template_data).result :rails_env => @rails_env, :ssl_hostname => @ssl_hostname
-      end
-    end
-  end
-end