conjure 0.2.10 → 0.3.0

data/lib/conjure/provision/postgres.rb

@@ -1,70 +0,0 @@
-require "conjure/provision/docker/template"
-require "securerandom"
-
-module Conjure
-  module Provision
-    class Postgres
-      def initialize(platform)
-        @platform = platform
-        @name = "conjure_db_#{SecureRandom.hex 8}"
-        @password = new_password
-      end
-
-      def start
-        @ip_address = server_template.build(@platform).start_daemon("/sbin/my_init", start_options)
-      end
-
-      def rails_config
-        {
-          "adapter" => "postgresql",
-          "database" => @name,
-          "host" => container_name,
-          "username" => "db",
-          "password" => @password,
-          "template" => "template0",
-        }
-      end
-
-      def container_link
-        {container_name => container_name}
-      end
-
-      private
-
-      def start_options
-        {
-          :name => container_name,
-          :volume_containers => [data_container_name],
-        }
-      end
-
-      def container_name
-        "postgres"
-      end
-
-      def data_container_name
-        data_template.build(@platform).start_volume(:name => "postgres_data")
-        "postgres_data"
-      end
-
-      def data_template
-        file = Docker::Template.new("conjure/postgres93:1.0.0")
-        file.volume "/var/lib/postgresql/9.3/main"
-        file
-      end
-
-      def server_template
-        file = Docker::Template.new("conjure/postgres93:1.0.0")
-        file.run "echo \"ALTER USER db PASSWORD '#{@password}'\" >/tmp/setpass"
-        file.run "/sbin/my_init -- /sbin/setuser postgres sh -c \"sleep 1; psql -f /tmp/setpass\""
-        file.run "rm /tmp/setpass"
-        file.run "/sbin/my_init -- /sbin/setuser db sh -c \"sleep 1; /usr/bin/createdb #{@name}\""
-        file
-      end
-
-      def new_password
-        SecureRandom.urlsafe_base64 20
-      end
-    end
-  end
-end

data/lib/conjure/provision/server.rb

@@ -1,78 +0,0 @@
-require "conjure/digital_ocean/droplet"
-require "securerandom"
-
-module Conjure
-  module Provision
-    class Server
-      def initialize(server)
-        @server = server
-        puts "Configuring droplet..."
-        install_swap
-      end
-
-      def ip_address
-        @server.ip_address
-      end
-
-      def run(command)
-        `ssh #{ssh_options} root@#{ip_address} '#{shell_escape_single_quotes command}'`
-      end
-
-      def send_file(local_name, remote_name)
-        `scp #{ssh_options} #{local_name} root@#{ip_address}:#{remote_name}`
-      end
-
-      def ssh_options
-        "-o StrictHostKeyChecking=no -o UserKnownHostsFile=/dev/null"
-      end
-
-      def shell_escape_single_quotes(command)
-        command.gsub("'", "'\"'\"'")
-      end
-
-      def install_swap
-        run "dd if=/dev/zero of=/root/swapfile bs=4096 count=524288"
-        run "mkswap /root/swapfile; swapon /root/swapfile"
-      end
-
-      def self.create(name, options = {})
-        puts "Creating DigitalOcean droplet..."
-        new DigitalOcean::Droplet.new(droplet_options(uniquify(name), options))
-      end
-
-      def self.droplet_options(name, options = {})
-        raise "Error: DIGITALOCEAN_API_TOKEN must be set." unless ENV["DIGITALOCEAN_API_TOKEN"]
-        {
-          image: "docker",
-          key_data: key_data,
-          name: name,
-          region: "nyc3",
-          size: (options[:instance_size] || "512mb"),
-          token: ENV["DIGITALOCEAN_API_TOKEN"],
-        }
-      end
-
-      def self.key_data
-        ssh_dir = File.expand_path "~/.ssh"
-        raise "Error: ~/.ssh/id_rsa.pub must exist." unless File.exist?(ssh_dir) && File.exist?("#{ssh_dir}/id_rsa.pub")
-        File.read "#{ssh_dir}/id_rsa.pub"
-      end
-
-      def self.uniquify(server_name)
-        "#{server_name}-#{SecureRandom.hex 4}"
-      end
-
-      def with_directory(local_path, &block)
-        local_archive = remote_archive = "/tmp/archive.tar.gz"
-        remote_path = "/tmp/unpacked_archive"
-        `cd #{local_path}; tar czf #{local_archive} *`
-        send_file local_archive, remote_archive
-        run "mkdir #{remote_path}; cd #{remote_path}; tar mxzf #{remote_archive}"
-        yield remote_path
-      ensure
-        `rm #{local_archive}`
-        run "rm -Rf #{remote_path} #{remote_archive}"
-      end
-    end
-  end
-end

data/lib/conjure/service/cloud_server.rb

@@ -1,112 +0,0 @@
-module Conjure
-  module Service
-    class CloudServer
-      require "pathname"
-      attr_reader :name
-
-      def initialize(name)
-        @name = name
-      end
-
-      def run(command, options = {}, &block)
-        set_fog_credentials
-        file_set = RemoteFileSet.new(:shell => remote_shell, :files => options[:files])
-        file_set.upload
-        result = remote_shell.run(command, :stream_stdin => options[:stream_stdin], &block)
-        file_set.remove
-        result
-      end
-
-      def server
-        @server ||= existing_server
-        @server ||= new_server
-        @server.wait_for { ready? }
-        @server
-      end
-
-      def ip_address
-        server.public_ip_address
-      end
-
-      def existing_server
-        @existing_server ||= connection.servers.find{|s| s.name == @name } if connection
-      end
-
-      def self.connection
-        new("").connection
-      end
-
-      def self.each_with_name_prefix(prefix, &block)
-        return unless connection
-        connection.servers.all.select{|s| s.name.match(/^#{prefix}/)}.each do |server|
-          block.call new(server.name)
-        end
-      end
-
-      def self.ensure_unique_name(name)
-        return name unless connection
-        existing_names = connection.servers.all.map{ |s| s.name }
-        name = increment_numeric_suffix(name) while existing_names.include? name
-        name
-      end
-
-      def self.increment_numeric_suffix(name)
-        parts = name.split("-")
-        parts[2] = parts[2] ? ((parts[2].to_i)+1).to_s : "2"
-        parts.join("-")
-      end
-
-      def new_server
-        Log.info " [cloud] Launching new server #{@name}"
-        bootstrap_options = account.bootstrap_options.merge(:name => @name)
-        options = prepare_bootstrap_options(bootstrap_options).merge(fog_credentials)
-        connection.servers.bootstrap options
-      end
-
-      def account
-        @account ||= Provider.all(:cloud_account).first
-      end
-
-      def connection
-        @connection ||= Fog::Compute.new account.compute_options if account
-      end
-
-      def add_resource_id(options, type)
-        id = "#{type}_id".to_sym
-        name = "#{type}_name".to_sym
-        collection = "#{type}s".to_sym
-        options[id] = resource_id(collection, options[name]) if options[name]
-      end
-
-      def prepare_bootstrap_options(options)
-        add_resource_id(options, :flavor)
-        add_resource_id(options, :region)
-        add_resource_id(options, :image)
-        options
-      end
-
-      def resource_id(collection, name)
-        connection.send(collection).find{|i| i.name == name}.id
-      end
-
-      def set_fog_credentials
-        Fog.credential = Conjure.identity.unique_identifier
-        Fog.credentials.merge! fog_credentials
-      end
-
-      def fog_credentials
-        {
-          private_key_path: Conjure.identity.private_key_path,
-          public_key_path: Conjure.identity.public_key_path,
-        }
-      end
-
-      def remote_shell
-        @remote_shell ||= RemoteShell.new(
-          :ip_address => server.public_ip_address,
-          :username => "root",
-        )
-      end
-    end
-  end
-end

data/lib/conjure/service/database.rb

@@ -1,25 +0,0 @@
-module Conjure
-  module Service
-    class Database
-      def self.new(options)
-        services_by_gem.each do |gem_name, service_class|
-          if options[:codebase].gem_names.include? gem_name
-            return service_class.new(
-              :target => options[:target],
-              :database_name => "rails_app_db",
-              :adapter_name => adapters_by_gem[gem_name],
-            )
-          end
-        end
-      end
-
-      def self.services_by_gem
-        {"pg" => Postgres, "mysql2" => Mysql, "mysql" => Mysql}
-      end
-
-      def self.adapters_by_gem
-        {"pg" => "postgresql", "mysql2" => "mysql2", "mysql" => "mysql"}
-      end
-    end
-  end
-end

data/lib/conjure/service/database/mysql.rb

@@ -1,69 +0,0 @@
-module Conjure
-  module Service
-    class Database
-      class Mysql
-        def initialize(options)
-          @target = options[:target]
-          @db_name = options[:database_name]
-          @adapter_name = options[:adapter_name]
-        end
-
-        def base_image
-          @base_image ||= @target.shell.prepare(
-            label: "mysql",
-            setup_commands: [
-              "apt-get install -y mysql-server mysql-client"
-            ],
-          )
-        end
-
-        def server_image
-          @server_image ||= base_image.prepare(
-            label: "mysqlserver",
-            setup_commands: [
-              "/usr/sbin/mysqld & sleep 5; echo \"GRANT ALL ON *.* TO root@'%' IDENTIFIED BY '' WITH GRANT OPTION\" | /usr/bin/mysql",
-            ],
-            daemon_command: "/usr/sbin/mysqld --bind-address=0.0.0.0",
-            volumes: ["/var/lib/mysql"],
-          )
-        end
-
-        def run
-          container
-        end
-
-        def container
-          @container ||= server_image.run
-        end
-
-        def name
-          @db_name
-        end
-
-        def ip_address
-          container.ip_address
-        end
-
-        def export(file)
-          File.open file, "w" do |f|
-            f.write base_image.command("/usr/bin/mysqldump #{client_options}")
-          end
-          Log.info "[export] #{File.size file} bytes exported to #{file}"
-        end
-
-        def import(file)
-          base_image.command "echo 'source /files/#{File.basename file}' | /usr/bin/mysql #{client_options}", files: [file]
-          Log.info "[import] #{File.size file} bytes imported from #{file}"
-        end
-
-        def client_options
-          "-u root -h #{ip_address} #{@db_name}"
-        end
-
-        def adapter_name
-          @adapter_name || "mysql2"
-        end
-      end
-    end
-  end
-end

data/lib/conjure/service/database/postgres.rb

@@ -1,77 +0,0 @@
-module Conjure
-  module Service
-    class Database
-      class Postgres
-        def initialize(options)
-          @target = options[:target]
-          @db_name = options[:database_name]
-        end
-
-        def base_image
-          @base_image ||= @target.shell.prepare(
-            label: "postgres",
-            setup_commands: [
-              "apt-get install -y python-software-properties software-properties-common",
-              "add-apt-repository -y ppa:pitti/postgresql",
-              "apt-get update",
-              "apt-get install -y postgresql-9.2 postgresql-client-9.2 postgresql-contrib-9.2",
-            ],
-          )
-        end
-
-        def server_image
-          @server_image ||= base_image.prepare(
-            label: "pgserver",
-            setup_commands: [
-              "service postgresql start; su postgres -c 'createuser -d -r -s root; createdb -O root root'; service postgresql stop",
-              "echo 'host all all 0.0.0.0/0 trust' >>/etc/postgresql/9.2/main/pg_hba.conf",
-              "echo \"listen_addresses='*'\" >>/etc/postgresql/9.2/main/postgresql.conf",
-            ],
-            daemon_command: "su postgres -c '#{bin_path}/postgres -c config_file=/etc/postgresql/9.2/main/postgresql.conf'",
-            volumes: ["/var/lib/postgresql/9.2/main"],
-          )
-        end
-
-        def run
-          container
-        end
-
-        def container
-          @container ||= server_image.run
-        end
-
-        def name
-          @db_name
-        end
-
-        def ip_address
-          container.ip_address
-        end
-
-        def export(file)
-          File.open file, "w" do |f|
-            f.write base_image.command("#{bin_path}/pg_dump #{client_options} #{@db_name}")
-          end
-          Log.info "[export] #{File.size file} bytes exported to #{file}"
-        end
-
-        def import(file)
-          base_image.command "#{bin_path}/psql #{client_options} -d #{@db_name} -f /files/#{File.basename file}", files: [file]
-          Log.info "[import] #{File.size file} bytes imported from #{file}"
-        end
-
-        def client_options
-          "-U root -h #{ip_address}"
-        end
-
-        def bin_path
-          "/usr/lib/postgresql/9.2/bin"
-        end
-
-        def adapter_name
-          "postgresql"
-        end
-      end
-    end
-  end
-end

data/lib/conjure/service/digital_ocean_account.rb

@@ -1,31 +0,0 @@
-module Conjure
-  module Service
-    class DigitalOceanAccount
-      include Conjure::Provider
-
-      provides :cloud_account do
-        new if configured?
-      end
-
-      def self.configured?
-        Conjure.config.digitalocean_api_key and Conjure.config.digitalocean_client_id
-      end
-
-      def compute_options
-        {
-          :provider => :digitalocean,
-          :digitalocean_api_key => Conjure.config.digitalocean_api_key,
-          :digitalocean_client_id => Conjure.config.digitalocean_client_id,
-        }
-      end
-
-      def bootstrap_options
-        {
-          :flavor_name => "512MB",
-          :region_name => (Conjure.config.digitalocean_region || "New York 1"),
-          :image_name => "Ubuntu 13.04 x64",
-        }
-      end
-    end
-  end
-end