Flucti-flucti-cli 0.1.16

data/lib/flucti/tasks/db_tasks.rb

@@ -0,0 +1,158 @@
+namespace :db do
+  namespace :server do
+    task(:default) { list }
+    import_pack(:connect, self, "database server")
+    
+    desc <<-DESC
+      List all database servers.
+    DESC
+    task :list do
+      puts_title "Database servers"
+      puts_list DbServer.all do |t|
+        t.col("Host") { |s| s.vps.hostname }
+        t.col("Port", :port)
+        t.col("Running as", :user)
+      end
+    end
+    
+    desc <<-DESC
+      Set up a new MySQL database server on a certain VPS.
+      
+      Environment variables:
+        (optional) $ON: the ID or hostname of the VPS to set up the server
+                        onto.
+                        Default: the newest VPS.
+    DESC
+    task :setup do
+      vps = fetch_vps
+      
+      db_server = vps.db_servers.build
+      try_save db_server do
+        puts_title "Request sent"
+        puts "Database server successfully scheduled for setup on #{q vps}."
+      end
+    end
+    
+    desc <<-DESC
+      Display the root credentials. One can only connect as root to 127.0.0.1
+      so commands that require root privilege must be executed directly on the
+      database server VPS, not any another one.
+      
+      For example:
+        $ #{command 'db:server:root'}
+        $ #{command 'db:server:enter'}
+        > env HISTFILE= mysql -h 127.0.0.1 -u root-1a28 -p'f6561b' foo -e 'SHOW TABLES'
+      
+      The above is actually equivalent to:
+        $ #{command 'db:server:run'} DB=foo Q='SHOW TABLES'
+      
+      Environment variables:
+        (optional) $ID: the ID of the server to display the root credentials of.
+                        Default: the last server set up.
+    DESC
+    task :root do
+      server = fetch_current
+      root = server.root
+      puts_long <<-EOS
+        * Host:     127.0.0.1
+        * Login:    #{root.login}
+        * Password: #{root.password}
+        
+        Query execution:
+        $ #{root.command_for_display '<database>', '<command>'}
+      EOS
+    end
+    
+    desc <<-DESC
+      Quick way to run a query as root on a database server.
+      
+      Example usage:
+        $ #{command "db:server:run"} Q="SHOW DATABASES"
+      
+      Environment variables:
+        (optional) $ID: the ID of the server to run the query in.
+                        Default: the last server set up.
+    DESC
+    task :run do
+      server = fetch_current
+      
+      queries = ENV["Q"] || (!$stdin.tty? and $stdin.read) or error! <<-MSG
+        Specify the query(ies) to execute either in the $Q environment
+        variable or through STDIN.
+      MSG
+      db = ENV["DB"]
+      
+      root = server.root
+      command = root.command(db, queries)
+      
+      server.vps.ssh_details.as(server.user).run(command)
+    end
+    
+    desc <<-DESC
+      List all the databases hosted on a certain server.
+
+      Environment variables:
+        (optional) $ID: the ID of the server to list the databases from.
+                        Default: the last server set up.
+    DESC
+    task :databases do
+      ENV["Q"] = "SHOW DATABASES"
+      run
+    end
+    
+    desc <<-DESC
+      Remove a database server. So is done by stopping the daemon and
+      soft-clearing all of the related files.
+      
+      That is, for a database server run as a UNIX account named `mysql', the
+      `mysql' account is removed, but the files are kept in /home/_mysql.
+      
+      Environment variables:
+        (optional) $ID: the ID of the server to remove.
+                        Default: the last server set up.
+    DESC
+    task :remove do
+      server = fetch_current
+      server.destroy
+      puts_long <<-MSG
+        Database server #{q server} successfully scheduled for removal.
+      MSG
+    end
+
+    def fetch_current
+      (id = ENV["ID"]) ? DbServer.find(id) : DbServer.last
+    end
+    
+    def fetch_vps
+      (id = ENV["ON"]) ? VPS.find(id) : VPS.last
+    end
+  end
+  
+  desc <<-DESC
+    Create a new database on a certain server. Once created, you will receive
+    the credentials via e-mail.
+    
+    Example usage:
+      $ #{command "db:create"} NAME=foo
+    
+    Environment variables:
+      (optional) $ID: the ID of the database server to create the database on.
+                      Default: the server last set up.
+  DESC
+  task :create do
+    name = ENV["NAME"] or error! <<-MSG
+      The name of the database to create must be specified in the $NAME
+      environment variable.
+    MSG
+    server = (id = ENV["ID"]) ? DbServer.find(id) : DbServer.last
+    db = server.databases.build :name => name
+    
+    try_save db do
+      puts_title "Request sent"
+      puts_long <<-MSG
+        Database #{q db} successfully created on #{q server}. Check your
+        e-mails for the connection details, including the credentials.
+      MSG
+    end
+  end
+end

data/lib/flucti/tasks/mail_tasks.rb

@@ -0,0 +1,104 @@
+namespace :mail do
+  namespace :server do
+    task(:default) { list }
+    
+    desc <<-DESC
+      List all VPS's acting as outgoing mail servers.
+    DESC
+    task :list do
+      puts_title "Mail servers"
+      puts_list MailServer.all, :id => false, :table => true do |t|
+        t.col("Host", :host)
+        t.col("Port", :port)
+      end
+    end
+    
+    desc <<-DESC
+      Set up an outgoing (SMTP) mail server on a VPS.
+      
+      ATTENTION:  Outgoing mail servers, like their name suggests, can only
+                  send e-mails out and cannot receive any. As a consequence,
+                  that they cannot be used as public Internet MX hosts (yet).
+      
+      After the setup has completed, you will be able to send out e-mails from
+      the mail server VPS in addition to any VPS configured as mail client of
+      that mail server (see #{qcommand "mail:client:setup"}). From these
+      VPS's, e-mails can be sent with for example:
+      
+      * Out-of-the-box:
+        - PHP's mail() function,
+        - Rails mailers (ActionMailer subclasses),
+        - the #{q "sendmail"} command,
+        - any other way that eventually relies on sendmail.
+      
+      * Any method that relies on SMTP, after configuring SMTP connection
+        details based on the output of #{qcommand 'mail:server:list'}.
+      
+      Environment variables:
+        (optional) $ON: the hostname of the VPS to set up the mail server on.
+                        Default: the newest VPS.
+    DESC
+    task :setup do
+      confirm <<-WARN
+        Any previously installed MTA (Mail Transfer Agent) will be removed
+        prior to configuring the new mail server.
+      WARN
+      
+      vps = mail.fetch_target_vps
+      mail_server = vps.build_mail_server
+      
+      try_save mail_server do
+        puts_title "Request sent"
+        puts "Mail server has been scheduled for setup on VPS #{q vps}."
+      end
+    end
+  end
+  
+  namespace :client do
+    desc <<-DESC
+      Configure a mail client on a VPS. This will enable e-mail sending via
+      a previously configured mail server on another VPS (see #{qcommand \
+      'mail:server:setup'}.
+      
+      For example, given a VPS `foo' and a VPS `bar':
+        $ #{command 'mail:server:setup'} ON=foo
+        $ #{command 'mail:client:setup'} ON=bar
+      
+      Environment variables:
+        (optional) $ON: the ID or hostname of the VPS to configure the mail
+                        client on.
+                        Default: the newest VPS.
+        
+        (optional) $OF or $SERVER:  the ID or hostname of the mail server VPS
+                                    that the client is to send e-mails
+                                    through.
+                                    Default: the mail server last set up.
+    DESC
+    task :setup do
+      id = ENV["SERVER"] || ENV["OF"]
+      unless server = id ? MailServer.find(id) : MailServer.last
+        error! <<-MSG
+          There is no mail server set up yet. To remedy this situation,
+          execute the following command:
+            $ #{command 'mail:server:setup'}
+        MSG
+      end
+      
+      server = server.vps
+      client = mail.fetch_target_vps
+      
+      mail_client = client.build_mail_client(:server => server)
+      
+      try_save mail_client do
+        puts_title "Request sent"
+        puts_long <<-MSG
+          Mail client of #{q server} successfully scheduled for setup on #{q client}.
+        MSG
+      end
+    end
+  end
+  
+  def fetch_target_vps
+    ENV["ON"] ? VPS.find(ENV["ON"]) : VPS.last
+  end
+end

data/lib/flucti/tasks/miscellaneous_tasks.rb

@@ -0,0 +1,6 @@
+desc "Open an IRB console with access to all resource classes."
+task :console do
+  require 'irb'
+  ARGV.clear
+  IRB.start(nil)
+end

data/lib/flucti/tasks/progress_tasks.rb

@@ -0,0 +1,24 @@
+desc <<-DESC
+  Show a progress-bar for in-progress operations. Blocks until 100% is
+  reached.
+  
+  When you create, alter or delete an entity, resulting in operations
+  necessary for the changes to take effect, like software installation and/or
+  configuration -- be it on one or several of your VPS's, and/or in our
+  registries -- these operations are started processing in the background on
+  our end.
+  
+  This task lets you know how much of these are left to do (roughly), and when
+  they are all done (accurately).
+DESC
+task :progress do
+  key, bar = nil, Utilities::ProgressBar.new("Progress", 100, $stdout)
+  loop do
+    progress = Progress.first(:key => key)
+    bar.set(progress.percent)
+    break if progress.percent >= 100
+    key = progress.key
+    sleep 2
+  end
+  bar.finish
+end

data/lib/flucti/tasks/sshkey_tasks.rb

@@ -0,0 +1,151 @@
+namespace :sshkey do
+  class PublicKeyPathNotFound < StandardError
+  end
+  
+  task(:default) { list }
+  
+  desc <<-DESC
+    List all registered SSH keys.
+  DESC
+  task :list do
+    puts_title "Registered SSH keys"
+    puts_list SshKey.all, :table => true do |t|
+      t.col("Public key") { |k| k.public_key.to_s[0, 50] + '...' }
+    end
+  end
+  
+  registration_env_vars = <<-DESC
+    Environment variables:
+      (optional) $FILE: path/to/id_{rsa,dsa}.pub
+                        Default:  your public key is searched
+                                  for at the usual locations.
+      
+      (optional) STDIN: the public key can be fed through STDIN instead of by
+                        path. Example:
+                        $ #{command "sshkey:register"} < path/to/the/key.pub
+  DESC
+  
+  desc <<-DESC
+    Register your public SSH key. You can register more than one. Doing so
+    grants you password-less SSH/SFTP/SCP access to all UNIX accounts created
+    either automatically or manually via #{qcommand "vps:user:add"}.
+    
+    Upon registration, the new key will be granted access all UNIX accounts of
+    all your VPS's (actually, only the ones that have a home folder). It will
+    also automatically be granted access to UNIX accounts created later.
+    
+#{registration_env_vars}
+  DESC
+  task :register do
+    current_key = local_key!
+    
+    puts_title "Registering SSH key"
+    puts "Public key at: #{current_key}"
+    
+    key = SshKey.new :public_key => current_key.read
+    try_save key do
+      puts_title "SSH key registered"
+      puts(key.public_key)
+    end
+  end
+  
+  desc <<-DESC
+    Make sure that your public key is registered; register it otherwise. If
+    you don't have a pair of keys (private and public) yet, one is attempted
+    to be generated for you at ~/.ssh.
+    
+    If even the generation failed, all UNIX accounts are switched to password
+    mode. In this mode, each time an account is created, a password is
+    generated for you to log in with. At creation time, an e-mail is sent to
+    you containing SSH connection details, including the generated password.
+    
+#{registration_env_vars}
+  DESC
+  task :ensure_registered do
+    begin
+      current_key = local_key
+    rescue PublicKeyPathNotFound
+      if system("which ssh-keygen")
+        sh %{echo | ssh-keygen -t dsa -P ''}
+        register
+      else
+        Account.put(:password_auth)
+        error! <<-MSG
+          You do not appear to already have an SSH key pair present at the
+          regular location. One has been attempted to be generated for you but
+          the #{q "ssh-keygen"} was missing.
+          
+          As a consequence, password-authentication have been enabled so that
+          you can connect to each account on your VPS's using passwords
+          instead of a public key.
+          
+          Also, whenever the #{q "ssh"} is supposed to be executed, you will
+          be presented with connections details for use in a graphical client
+          application such as PuTTy and WinSCP (for Windows).
+        MSG
+      end
+    else
+      puts_title "Status of your public key"
+      begin
+        SshKey.create :public_key => current_key.read
+      rescue WebService::ResourceInvalid
+        puts "The public key of the current user (#{ENV['USER']}) is registered."
+      else
+        puts "The public key of the current user (#{ENV['USER']}) has been registered successfully."
+      end
+    end
+  end
+  
+  desc <<-DESC
+    Unregister a key. It will be revoked access from all UNIX accounts it is
+    currently granted access to, and won't be automatically granted access to
+    the UNIX account of new website backends anymore.
+    
+    Environment variables:
+      $ID: the ID of the key to unregister (get the list with #{qcommand "sshkey:list"}).
+  DESC
+  task :unregister do
+    id = require_id!
+    
+    SshKey.delete(id)
+    puts_title "Request sent"
+    puts "SSH key successfully scheduled for unregistration."
+  end
+  
+  def require_id!
+    ENV["ID"] or
+      error! <<-MSG
+        The ID of the key to deal with must be specified by setting the ID
+        environment variable. To list all registered SSH keys, run
+        #{qcommand "sshkey:list"}.
+      MSG
+  end
+  
+  def local_key!
+    local_key
+  rescue PublicKeyPathNotFound
+    error! $!.message
+  end
+  
+  def local_key
+    if !$stdin.tty?
+      file = STDINWrapper.new
+    elsif path = ENV["FILE"]
+      file = Pathname(path)
+      raise PublicKeyPathNotFound, "No such file: #{path}." unless file.file?
+    else
+      file = Pathname.glob("{.,#{ENV['HOME']}/.{ssh,ssh2}}/id_{dsa,rsa}.pub{,.txt}").first
+    end
+    file or raise PublicKeyPathNotFound, "Could not guess the path of your public SSH key."
+  end
+  
+  class STDINWrapper
+    def to_s
+      "STDIN"
+    end
+    
+    def read
+      $stdin.gets
+    end
+  end
+end