conjure 0.2.10 → 0.3.0

data/lib/conjure/service/rake_task.rb

@@ -1,11 +0,0 @@
-module Conjure
-  module Service
-    class RakeTask
-      def initialize(options, &block)
-        task = options[:task]
-        shell = options[:shell]
-        shell.command("cd application_root; bundle exec rake #{task}", &block)
-      end
-    end
-  end
-end

data/lib/conjure/service/remote_file_set.rb

@@ -1,24 +0,0 @@
-module Conjure
-  module Service
-    class RemoteFileSet
-      require "net/scp"
-
-      def initialize(options)
-        @shell = options[:shell]
-        @files = options[:files].to_a
-      end
-
-      def upload
-        dir_names = @files.map{|local_path, remote_path| File.dirname remote_path}.uniq
-        @shell.run "mkdir -p #{dir_names.join ' '}" if dir_names.any?
-        @files.each do |local_path, remote_path|
-          @shell.session.scp.upload! local_path, remote_path
-        end
-      end
-
-      def remove
-        @files.each{|local_path, remote_path| @shell.run "rm -f #{remote_path}"}
-      end
-    end
-  end
-end

data/lib/conjure/service/remote_shell.rb

@@ -1,73 +0,0 @@
-module Conjure
-  module Service
-    class RemoteShell
-      require "net/ssh"
-
-      class << self
-        attr_accessor :ssh_service
-      end
-      @ssh_service = Net::SSH
-
-      def initialize(options = {})
-        @options = options
-      end
-    
-      def run(command, options = {}, &block)
-        Log.debug "   [ssh] #{command}"
-        result = nil
-        session.open_channel do |channel|
-          channel.request_pty
-          channel.exec command do |c, success|
-            raise "Failed to execute command via SSH" unless success
-            result = Result.new(channel, &block)
-          end
-          if options[:stream_stdin]
-            channel.on_process do
-              poll_stream(STDIN) { |data| channel.send_data data }
-            end
-          end
-        end
-        if options[:stream_stdin]
-          with_raw_tty { session.loop 0.01 }
-        else
-          session.loop
-        end
-        result
-      end
-
-      def session
-        session_options = {
-          :auth_methods => ["publickey"],
-          :paranoid => false,
-          :forward_agent => true,
-        }
-        @session ||= self.class.ssh_service.start @options[:ip_address], @options[:username], session_options
-      end
-
-      def poll_stream(stream, &block)
-        yield stream.sysread(1) if IO.select([stream], nil, nil, 0.01)
-      end
-
-      def with_raw_tty
-        system "stty raw -echo"
-        yield
-      ensure
-        system "stty -raw echo"
-      end
-
-      class Result
-        attr_accessor :stdout, :stderr, :status
-        def initialize(channel)
-          @stdout, @stderr = "", ""
-          channel.on_data do |c, data|
-            yield data if block_given?
-            @stdout << data
-          end
-          channel.on_extended_data { |c, type, data| @stderr << data }
-          channel.on_request("exit-status") { |c, data| @status = data.read_long }
-        end
-      end
-    end
-
-  end
-end

data/lib/conjure/service/repository_link.rb

@@ -1,52 +0,0 @@
-module Conjure
-  module Service
-    class RepositoryLink
-      def initialize(options)
-        @volume = options[:volume]
-        @branch = options[:branch]
-        @origin_url = options[:origin_url]
-        @public_key = options[:public_key]
-      end
-
-      def update
-        code_checked_out ? fetch_code_updates : checkout_code
-      end
-
-      def branch
-        @branch ||= git_shell.command("cd #{code_path}; git rev-parse --abbrev-ref HEAD").strip
-      end
-
-      private
-
-      def code_checked_out
-        git_shell.command("[ -d #{code_path}/.git ] && echo yes; true").strip == "yes"
-      end
-
-      def checkout_code
-        Log.info "[  repo] Checking out code from git"
-        output = git_shell.command "git clone -b #{@branch} #{@origin_url} #{code_path}"
-        raise "Access denied to git repo" if output.include? "Permission denied"
-      end
-
-      def fetch_code_updates
-        Log.info "[  repo] Fetching code updates from git"
-        git_shell.command "cd #{code_path}; git reset --hard; git checkout #{@branch}; git pull"
-      end
-
-      def code_path
-        @volume.container_path
-      end
-
-      def git_shell
-        @git_shell ||= ForwardedShell.new(:shell => @volume.shell.prepare({
-          label: "git",
-          setup_commands: [
-            "apt-get install -y git",
-            "mkdir -p /root/.ssh",
-            "echo 'Host github.com\\n\\tStrictHostKeyChecking no\\n' >> /root/.ssh/config",
-          ],
-        }), :public_key => @public_key)
-      end
-    end
-  end
-end

data/lib/conjure/service/volume.rb

@@ -1,28 +0,0 @@
-module Conjure
-  module Service
-    class Volume
-      attr_reader :target, :container_path
-
-      def initialize(options)
-        @target = options[:target]
-        @host_path = options[:host_path]
-        @container_path = options[:container_path]
-      end
-
-      def read(filename)
-        shell.command "cat #{@container_path}/#{filename}"
-      end
-
-      def write(filename, data)
-        shell.command "echo '#{data}' >#{@container_path}/#{filename}"
-      end
-
-      def shell
-        @shell ||= @target.shell.prepare(
-          :label => "volume",
-          :host_volumes => {@host_path => @container_path},
-        )
-      end
-    end
-  end
-end

data/lib/conjure/target.rb

@@ -1,19 +0,0 @@
-module Conjure
-  class Target
-    def initialize(options)
-      @machine_name = options[:machine_name]
-    end
-
-    def shell
-      docker_host.shell
-    end
-
-    def ip_address
-      docker_host.ip_address
-    end
-
-    def docker_host
-      @docker_host ||= Service::DockerHost.new @machine_name
-    end
-  end
-end

data/lib/conjure/view/application_view.rb

@@ -1,42 +0,0 @@
-require "conjure"
-
-module Conjure
-  module View
-    class ApplicationView
-      def initialize(application)
-        @application = application
-        @instances = @application.instances
-      end
-
-      def render
-        [application_content, instances_content].join "\n\n"
-      end
-
-      private
-
-      def application_content
-        content = ["Showing application status (Conjure v#{Conjure::VERSION})"]
-        content << "Origin  #{@application.origin}"
-        content.join "\n"
-      end
-
-      def instances_content
-        content = ["Deployed Instances:"]
-        content << instances_table
-        content << "(none)" unless @instances.any?
-        content.join "\n"
-      end
-
-      def instances_table
-        data = @instances.map do |instance|
-          {
-            "Name" => instance.name,
-            "Status" => instance.status,
-            "Address" => instance.ip_address,
-          }
-        end
-        TableView.new(data).render
-      end
-    end
-  end
-end

data/lib/conjure/view/table_view.rb

@@ -1,38 +0,0 @@
-module Conjure
-  module View
-    class TableView
-      def initialize(data)
-        @data = data
-        calculate_widths
-      end
-
-      def render
-        rows = [@width.map{|col, width| pad_to_width(col, width)}.join(column_separator)]
-        rows += @data.map do |row|
-          @width.map{|col, width| pad_to_width(row[col], width)}.join(column_separator)
-        end
-        rows.join("\n")
-      end
-
-      private
-
-      def column_separator
-        "  "
-      end
-
-      def pad_to_width(string, width)
-        string.to_s + " "*(width - string.to_s.length)
-      end
-
-      def calculate_widths
-        @width = {}
-        @data.each do |row|
-          row.each_pair do |key, value|
-            @width[key] ||= key.to_s.length
-            @width[key] = [@width[key], value.to_s.length].max
-          end
-        end
-      end
-    end
-  end
-end