Flucti-flucti-cli 0.1.16

data/lib/flucti/resources/ssh_details.rb

@@ -0,0 +1,96 @@
+module Flucti
+  module Resources
+    class SshDetails < BasicResource
+      def as(login)
+        AccountBinding.new(self, login)
+      end
+
+      def connection
+        as(login)
+      end
+
+    private
+
+      class AccountBinding < Struct.new(:details, :login)
+        delegate :host, :port, :to => :details
+
+        def connection_command
+          "ssh -p #{port} #{login}@#{host}"
+        end
+
+        def connect
+          check_for_presence_of_ssh do
+            command = connection_command
+            $stderr.puts "Connecting to VPS with: `#{command}'"
+            exec(command)
+          end
+        end
+
+        def execute_command(command)
+          %(#{connection_command} 'echo "#{command.gsub /"/, '\"'}" | bash -l -s')
+        end
+
+        def execute(command)
+          check_for_presence_of_ssh do
+            command = execute_command(command)
+            $stderr.puts "Executing: #{command}"
+
+            # For some reason, `exec' won't work, it throws the following error:
+            # `Operation not supported' (Errno::E045).  `system' causes this too
+            # sometimes, but so much less often that it's bearable.
+            system(command)
+          end
+        end
+        alias run :execute
+
+        def upload(*files)
+          check_for_presence_of_scp do
+            command = %(scp -P #{port} #{files * ' '} #{login}@#{host}:~)
+            $stderr.puts "Executing: #{command}"
+            system(command)
+          end
+        end
+
+      private
+
+        def check_for_presence_of_ssh
+          if has_command? 'ssh'
+            yield
+          else
+            suggest_windows_alternative "ssh", "PuTTY", "http://www.chiark.greenend.org.uk/~sgtatham/putty"
+          end
+        end
+
+        def check_for_presence_of_scp
+          if has_command? 'scp'
+            yield
+          else
+            suggest_windows_alternative "scp", "WinSCP", "http://winscp.net"
+          end
+        end
+        
+        def has_command?(command)
+          case RUBY_PLATFORM
+          when /mswin/
+            false
+          else
+            system("which ssh > /dev/null 2>&1")
+          end
+        end
+
+        def suggest_windows_alternative(missing, alternative, url)
+          Utilities.error! <<-MSG
+            The necessary `#{missing}' utility seems missing on your system. You
+            should connect to the VPS manually with #{alternative} (for Windows,
+            available at #{url}) using the following connection details :
+
+            * Host:     #{host}
+            * Port:     #{port}
+            * Login:    #{login}
+            * Password: (not needed -- specify your public SSH key instead)
+          MSG
+        end
+      end
+    end
+  end
+end

data/lib/flucti/resources/webserver.rb

@@ -0,0 +1,9 @@
+module Flucti
+  module Resources
+    class Webserver < BasicResource
+      belongs_to :container
+      has_many :backends
+      has_one :ssh_details
+    end
+  end
+end

data/lib/flucti/resources/website.rb

@@ -0,0 +1,9 @@
+module Flucti
+  module Resources
+    class Website < BasicResource
+      self.attribute_for_to_s = :name
+      has_many :domains
+      has_many :backends
+    end
+  end
+end

data/lib/flucti/tasks.rb

@@ -0,0 +1,3 @@
+Dir.glob(File.dirname(__FILE__) + "/tasks/**/*_tasks.rb") do |task_file|
+  load(task_file)
+end

data/lib/flucti/tasks/apikey_tasks.rb

@@ -0,0 +1,57 @@
+namespace :apikey do
+  desc <<-DESC
+    Reset your API key and generate a new one. The new key will be sent to you
+    by e-mail.
+  DESC
+  task :reset do
+    APIKey.put
+    
+    puts_title "API key reset"
+    puts_long <<-MSG
+      Your API key has been reset. You will receive an e-mail with your new
+      API key shortly. After that, you will need to reconfigure this utility
+      to use the new key, by running #{qcommand "apikey:switch"}.
+    MSG
+  end
+  
+  desc <<-DESC
+    Change the current API key. You should use this task after #{qcommand "apikey:reset"}
+    to use a newly generated API key.
+  DESC
+  task :switch do
+    puts_title "API key"
+    puts_long <<-MSG
+      In order to use this utility, you must provide your API key that must
+      have been sent to you in an e-mail after creating your account. Please
+      paste it at the prompt below and press <enter>.
+    MSG
+    prompt_and_store_key
+  end
+  
+  def prompt_and_store_key
+    loop do
+      puts
+      print "API key: "
+      entered = $stdin.gets.strip
+      begin
+        APIKey.site = APIAccess.site_with_api_key(entered)
+        begin
+          APIKey.get
+        ensure
+          APIKey.site = nil
+        end
+      rescue WebService::UnauthorizedAccess
+        puts
+        puts_long <<-MSG
+          The key you entered apears to be invalid. Please double check it
+          and retry, or let us help you: #{SUPPORT_EMAIL_ADDR}.
+        MSG
+      else
+        Parameters.store(:api_key, entered)
+        puts
+        puts "* Key valid and saved."
+        break
+      end
+    end
+  end
+end

data/lib/flucti/tasks/apptype_tasks.rb

@@ -0,0 +1,264 @@
+namespace :apptype do
+  task(:default) { list }
+  
+  desc <<-DESC
+    Display a list of all the stock application types.
+    
+    These are only suggestions that a website can be automatically configured
+    for running. Of course, you can configure your VPS's to run any kind of
+    site you want, either by customizing existing types (see #{qcommand \
+    'apptype:import'} and #{qcommand 'apptype:push'}), or by configuring
+    everything manually.
+  DESC
+  task :list do
+    puts_title "Available application types"
+    puts_list AppType.all, :id => :short, :table => true do |t|
+      t.col("Name", :name)
+      t.col("Stock?") { |t| '*' if t.stock? }
+    end
+  end
+  
+  desc <<-DESC
+    Display brief details about an application type. 
+  DESC
+  task :show do
+    id = require_id!
+    display(AppType.find(id))
+  end
+  
+  desc <<-DESC
+    Import files from an existing type into the current working directory.
+    
+    This is usually the first step in creating a custom type. It's usually
+    followed by the customisation of the imported files, and finalised with a
+    #{qcommand 'apptype:push'}.
+  DESC
+  task :import do
+    id = require_id!
+    
+    type = AppType.find(id)
+    puts_title "Importing type #{q type}"
+    
+    # (utilities)
+    secure_write = lambda do |path, contents|
+      path = path.gsub(/\{(.*?)\}/) { $1.split(',').first }
+      if File.exist?(path) || File.exist?(path.downcase)
+        $stderr.puts "Warning: skipping #{q path} as it already exists"
+      else
+        puts "Writing #{q path}"
+        File.open(path, 'w') { |f| f << contents }
+      end
+    end
+    
+    # Files
+    file_map_for_type.each do |attribute, glob|
+      secure_write[glob, type.send(attribute)]
+    end
+    
+    # Metadata
+    filter_out = ['id', 'stock?', *file_map_for_type.stringify_keys.keys]
+    data =
+      type.attributes.
+        stringify_keys.
+        except(*filter_out).
+        merge('name' => name_of_current, 'short' => name_of_current)
+    secure_write["meta.yml", YAML.dump(data)]
+    
+    # Services
+    type.service_configs.each do |service|
+      file_map_for_service.each do |attribute, glob|
+        path = ([service.name, glob] - %w(main)).join('_')
+        data = service.send(attribute)
+        secure_write[path, data]
+      end
+    end
+  end
+  
+  desc <<-DESC
+    Create a new application type or update an existing one. The files in the
+    current working directory are used to build a new or updated type which is
+    then registered under the name of that directory.
+    
+    Creating a new type usually goes somewhat like this:
+      $ mkdir foo-type && cd foo-type
+      $ #{command "apptype:import"} ID=sinatra
+      # ...Edit the imported files...
+      $ #{command "apptype:push"}
+      # ...Edit the files..
+      $ #{command "apptype:push"}
+    
+    Custom types can be used like the stock ones. For a new site:
+      $ #{command "website:declare"} TYPE=foo
+
+    Or, for an existing site:
+      $ cd path/to/some-site
+      $ #{command "website:apptype:switch"} ID=foo
+      $ #{command "website:backends:reprepare"}
+    
+    To update a type:
+      $ cd foo-type
+      # ...Edit the files...
+      $ #{command "apptype:push"}
+      # ...For each website of that type...
+      $ #{command "website:backends:reprepare"}
+  DESC
+  task :push do
+    if type = AppType[name_of_current]
+      update type
+    else
+      create type
+    end
+  end
+  
+  desc <<-DESC
+    Delete an existing type. All website of this type must have been deleted
+    before running this tasks.
+  DESC
+  task :delete do
+    id = require_id!
+    type = AppType.find(id)
+    begin
+      type.destroy
+    rescue WebService::ResourceConflict
+      error! $!.response.data['errors']
+    else
+      puts_title "Application type deleted"
+      puts "Application type #{q type} deleted successfully."
+    end
+  end
+  
+  def require_id!
+    ENV["ID"] or
+      error! <<-MSG
+        The ID or short name of the application type to deal with must be
+        specified in the $ID environment variable. To list all application
+        types, run #{qcommand "apptype:list"}.
+      MSG
+  end
+  
+  def build_type_from_cwd
+    type = AppType.new
+    dir = Pathname.pwd
+    
+    # (utilities)
+    assign_to = lambda do |object, map|
+      map.each do |attribute, glob|
+        file = Pathname.glob(dir.join(glob)).first
+        object.write_attribute(attribute, file.read) if file
+      end
+    end
+    
+    # Metadata
+    meta = dir.join("meta.yml")
+    type.attributes = YAML.load(meta.read) if meta.file?
+    
+    # Here is not really the place to assign a default name and short name but
+    # since callers of this method expect these attributes to be set, I think
+    # it's OK.
+    type.name = name_of_current unless type.attribute_set?(:name)
+    type.short = type.name unless type.attribute_set?(:short)
+    
+    # Files
+    assign_to[type, file_map_for_type]
+    
+    # Build the main ServiceConfig:
+    #   start.sh  => main.start_script
+    #   finish.sh => main.finish_script
+    if file_map_for_service.values.any? { |f| File.file? f }
+      main = ServiceConfig.new(:name => "main")
+      assign_to[main, file_map_for_service]
+    end
+    
+    # Build other ServiceConfig's:
+    #   foo_start.sh    => foo.start_script
+    #   foo_install.sh  => foo.finish_script
+    other =
+      Pathname.glob(dir.join("*_{#{file_map_for_service.values * ','}}")).
+        group_by { |p| p.basename.to_s.split('_', 2).first }.
+        map do |name, files|
+          service = ServiceConfig.new(:name => name)
+          file_map =
+            file_map_for_service.inject({}) do |m, (attr, file)|
+              if path = files.find { |path| path.basename.to_s.split('_', 2).last == file }
+                m[attr] = path
+              end
+              m
+            end
+          assign_to[service, file_map]
+          service
+        end
+    
+    return type, [main, *other].compact
+  end
+  
+  def display(type)
+    puts "Name:             #{type.name}"
+    puts "Short name:       #{type.short}"
+    puts "Stock?:           #{type.stock? ? 'Yes' : 'No'}"
+    puts "Created:          #{type.created_at}"
+    puts "Updated:          #{type.updated_at}"
+    puts "Detection:        #{(d = type.detection) ? "test -#{d}" : '(none)'}"
+    puts "Install script:   (#{type.install_script.to_s.length} bytes)"
+    puts "Webserver conf.:  (#{type.webserver_conf.to_s.length} bytes)"
+    puts "Capfile tmpl.:    (#{type.capfile.to_s.length} bytes)"
+    if type.service_configs.any?
+      puts "Services:"
+      type.service_configs.each do |service|
+        puts "- #{service}"
+      end
+    else
+      puts "Services:         (none)"
+    end
+  end
+  
+  def name_of_current
+    ENV["NAME"] || clean_name(Pathname.pwd.expand_path.basename.to_s.gsub(/^type-|-type$/, ""))
+  end
+  
+  def file_map_for_type
+    { :root_install_script => "root_install.sh", :install_script => "install.sh",
+      :webserver_conf => "nginx.conf", :capfile => "{C,c}apfile" }
+  end
+  
+  def file_map_for_service
+    { :start_script => "start.sh", :finish_script => "finish.sh" }
+  end
+  
+  def create(type)
+    type, services = build_type_from_cwd
+    
+    try_save type do
+      puts_title "Application type created"
+      puts "Creating associated service configurations..."
+      services.each do |service|
+        service.app_type = type
+        try_save service do
+          puts "- Created service #{q service}"
+        end
+      end
+      puts
+      display(type.reload)
+    end
+  end
+  
+  def update(type)
+    updated, services = build_type_from_cwd
+    updated.attributes.except('id').each do |attribute, value|
+      type.write_attribute(attribute, value)
+    end
+    
+    try_save type do
+      puts_title "Application type updated"
+      puts "Updating associated service configurations..."
+      type.service_configs.each &:destroy
+      services.each do |service|
+        service.app_type = type
+        try_save service do
+          puts "- Updated service #{q service}"
+        end
+      end
+      puts
+      display(type.reload)
+    end
+  end
+end

data/lib/flucti/tasks/connect_pack.rb

@@ -0,0 +1,161 @@
+desc <<-DESC
+  Open a new shell in the specified #{resource_type}'s UNIX account.
+  For password-less access, be sure to run #{qcommand "sshkey:register"}
+  first.
+
+  Environment variables:
+    (optional) $ID: the ID of the #{resource_type} to connect to.
+    (optional) $AS: the login of the UNIX account to connect as.
+DESC
+namespace :connect do
+  task :default do
+    resource = fetch_current
+    ssh_details_for(resource).connect
+  end
+
+  desc <<-DESC
+    Display SSH connection details. You can then use these details to connect
+    to the #{resource_type} either from the command line (using the standard
+    `ssh', `scp' or `sftp' tool suite), programmatically using Net::SSH, or
+    graphically using WinSCP or Cyberduck.
+
+    Environment variables:
+      (optional) $ID: the ID of the #{resource_type} to get the
+                      connection details for.
+  DESC
+  task :details do
+    resource = fetch_current
+    details = ssh_details_for(resource)
+
+    puts_long <<-EOS
+      SSH connection details for #{resource_type} #{resource}:
+      * Host:   #{details.host}
+      * Port:   #{details.port}
+      * Login:  #{details.login}
+      
+      Remote command execution:
+      $ ssh -p #{details.port} #{details.login}@#{details.host} <command>
+      
+      File upload:
+      $ scp -P #{details.port} #{details.login}@#{details.host} <local-path> <remote-path>
+    EOS
+  end
+
+  # Allow for defining a method named `command'.
+  class << self
+    undef_method :command if method_defined? :command
+  end
+  
+  desc <<-DESC
+    Output an SSH connection command, ready to run.
+
+    Environment variables:
+      (optional) $ID: the ID of the #{resource_type} to get the connection
+                      command for.
+  DESC
+  task :command do
+    resource = fetch_current
+    puts ssh_details_for(resource).connection_command
+  end
+
+  def ssh_details_for(resource)
+    details = resource.ssh_details
+    details.login = ENV["AS"] || 'root' unless details.attribute_set? :login
+  
+    # Return `details.connection' instead of `details' so that methods
+    # of both SshDetails and SshDetails::AccountBinding are made
+    # available from the same object.
+    details.connection
+  rescue WebService::NotAcceptable
+    vps = resource.attribute_set?(:vps) ? resource.vps : resource
+    reference = vps == resource ? "VPS" : "#{resource_type}'s VPS"
+    error! <<-MSG
+      The SSH port of the #{reference} (#{q vps}) is not accessible
+      from the Internet. You need to open it in order to be able
+      to connect to the #{resource_type}'s UNIX account. To do so,
+      run #{qcommand "vps:firewall:open PORT=22"}.
+    MSG
+  end
+end
+
+desc "Alias for task `connect'."
+task(:enter) { connect.default }
+
+desc <<-DESC
+  Run a command in the #{resource_type} environment. Default working
+  directory is the home directory.
+
+  Environment variables:
+    (mandatory) $CMD: the command to run.
+
+    (optional)  $ID:  the ID of the #{resource_type} to run the command
+                      in.
+DESC
+task :run do
+  cmd = ENV['CMD'] or error! <<-MSG
+    The command to execute must be specified in the $CMD environment
+    variable.
+  MSG
+  resource = fetch_current
+  connect.ssh_details_for(resource).run(cmd)
+end
+
+desc <<-DESC
+  Upload a local file to the home directory of the #{resource_type}.
+
+  Environment variables:
+    (mandatory) $FILE:  the path to the file to upload.
+
+    (optional)  $ID:    the ID of the #{resource_type} to upload the
+                        file to.
+DESC
+task :upload do
+  files = ENV['FILE'] || ENV['FILES'] or error! <<-MSG
+    The file to upload must be specified in the $FILE environment
+    variable.
+  MSG
+  resource = fetch_current
+  connect.ssh_details_for(resource).upload(*Dir[files])
+end
+
+namespace :rubygems do
+  desc <<-DESC
+    Install or update RubyGems (latest version) on the UNIX account of the
+    specified #{resource_type}. Ruby will be installed if necessary (latest
+    1.8).
+
+    Once you have done that, you can connect to the #{resource_type}'s
+    UNIX account and start installing gems. For example:
+      $ #{command "db:server:rubygems:install"}
+      $ #{command "progress"}
+      $ #{command "db:server:enter"}
+      mysql@filiberto ~ $ gem install rails
+
+    Environment variables:
+      (optional) $ID: the ID of the #{resource_type} to install RubyGems onto.
+                      Default: the last #{resource_type}.
+  DESC
+  task :install do
+    resource = fetch_current
+
+    resource.post(:rubygems)
+
+    puts_title "Request sent"
+    puts "RubyGems (latest version) has been scheduled for installation or update on #{resource_type} #{resource}."
+  end
+
+  desc "Alias for `install'."
+  task(:setup) { install }
+
+  desc <<-DESC
+    Update RubyGems to the latest version. Only the package management
+    system is updated, not the gems themselves.
+
+    Environment variables:
+      (optional) $ID: the ID of the #{resource_type} to update RubyGems on.
+                      Default: the last #{resource_type}.
+  DESC
+  task(:update) do
+    install
+  end
+end