Flucti-flucti-cli 0.1.16

data/lib/flucti/tasks/vps/firewall_tasks.rb

@@ -0,0 +1,84 @@
+namespace :vps do
+  namespace :firewall do
+    # Allow for defining task named `open':
+    class << self
+      undef_method :open if private_method_defined? :open
+    end
+    
+    task(:default) { rules }
+    
+    desc <<-DESC
+      Open a port from the Internet to a VPS. For example, if you choose to
+      open port 443 of a VPS foo, it will be accessible from the Internet on a
+      port greater than or equal to 1025, like 1047. As a result, packets
+      would arrive like this:
+
+        Internet <=> (Firewall:1047) <=> VPS:443
+
+      Following on this example:
+        $ #{command 'vps:firewall:open'} PORT=443
+
+      As 443 is the default HTTP SSL port number, you can a host site over SSL
+      and it will be accessible from the Internet on port 1047, for example at
+      https://www.example.com:1047.
+      
+      By default, a port is open from the Internet. But you can restrict the
+      access to only one or several of your VPS's by specifying the $FROM
+      variable.
+      
+      For example, to open port 3306 (MySQL) of VPS #{q 'trever'} to another
+      VPS #{q 'christina'}:
+        $ #{command 'vps:firewall:open'} FROM=christina ID=trever PORT=3306
+
+      Environment variables:
+        (mandatory) $PORT:  the destination port number on the VPS, in the form
+                            of <port>[:<protocol>], where <protocol> is optional
+                            and is one of TCP or UDP, TCP being the default if
+                            none is specified. For example:
+                              $ #{command 'vps:firewall:open'} PORT=443
+                            Is equivalent to:
+                              $ #{command 'vps:firewall:open'} PORT=443:TCP
+
+        (optional)  $FROM:  the origin to grant access to. It can be either a
+                            VPS identified by its hostname, or the Internet,
+                            identified by #{q 'internet'}. Valid values
+                            include:
+                              FROM=internet   # default
+                            Or:
+                              FROM=foo        # VPS whose hostname is `foo'
+
+        (optional)  $ID:    the ID or hostname of the destination VPS.
+                            Default: the newest VPS.
+    DESC
+    task :open do
+      vps = top.vps.fetch_current
+      port = ENV["PORT"] or error! <<-MSG
+        The destination port must be specified in the $PORT environment
+        variable, in the form of <port>[:<protocol>].
+        Examples: PORT=443, PORT=443:TCP, PORT=53:UDP
+      MSG
+      sources = (ENV['FROM'] || 'internet').split(',')
+      number, protocol = port.to_s.split(':')
+      protocol ||= 'TCP'
+      fwd = vps.port_forwardings.build :sources => sources, :to => number, :protocol => protocol
+      try_save fwd do
+        puts_title "Request sent"
+        puts "#{fwd.protocol.to_s.upcase} port #{fwd.to} has been scheduled for opening on VPS #{vps}."
+      end
+    end
+    
+    desc <<-DESC
+      List all firewall rules defined for a given VPS.
+    DESC
+    task :rules do
+      vps = top.vps.fetch_current
+      
+      puts_title "Firewall rules for VPS #{q vps}"
+      puts_list vps.port_forwardings.all, :table => true do |t|
+        t.col("Service") { |f| f.service_name || "(#{f.protocol})" }
+        t.col("Sources") { |f| "{#{f.simplified_sources * ', '}}:#{f.from}" }
+        t.col("Destination") { |f| "#{f.target}:#{f.to}" }
+      end
+    end
+  end
+end

data/lib/flucti/tasks/vps_tasks.rb

@@ -0,0 +1,37 @@
+namespace :vps do
+  task(:default) { list }
+  import_pack(:connect, self, "VPS")
+  
+  desc <<-DESC
+    Display a list of all your VPS's.
+  DESC
+  task :list do
+    puts_title "All VPS's"
+    puts_list VPS.all do |t|
+      t.col("Hostname", :hostname)
+      t.col("Memory capacity") { |s| "#{s.memory_capacity} MB" }
+      t.col("Disk capacity") { |s| "#{s.disk_capacity} GB" }
+      t.col("Status") { |s| s.status.to_s.capitalize }
+    end
+  end
+  
+  desc <<-DESC
+    Display a list of hostsnames of all your VPS's. Useful for refering to
+    these programmatically.
+  DESC
+  task :hostnames do
+    VPS.all.each { |vps| puts vps.hostname }
+  end
+  
+  desc <<-DESC
+    List all users (UNIX accounts) that have a home folder.
+  DESC
+  task :users do
+    ENV['CMD'] = "ls /home | grep -v ^_"
+    run
+  end
+  
+  def fetch_current
+    (id = ENV["ID"] || ENV["ON"]) ? VPS.find(id) : VPS.last
+  end
+end

data/lib/flucti/tasks/webserver_tasks.rb

@@ -0,0 +1,154 @@
+namespace :webserver do
+  task(:default) { list }
+  import_pack(:connect, self, "webserver")
+  
+  desc <<-DESC
+    List all webservers on either a particular VPS, or all VPS's.
+    
+    Environment variables:
+      (optional) $ON: hostname of the VPS to list the webservers of.
+                      Default: the newest VPS.
+  DESC
+  task :list do
+    puts_title "All webservers"
+    puts_list particular_set_of_webservers || Webserver.all, :title => :vps do |t|
+      t.col("Running on", :vps)
+      t.col("Running as", :user)
+    end
+  end
+  
+  desc <<-DESC
+    Make sure that at least one webserver is present. Failing that, one is set
+    up automatically on the newest VPS.
+  DESC
+  task :ensure_any do
+    if (count = Webserver.all.size).zero?
+      setup
+    else
+      puts_title "Webserver present"
+      puts "There exists #{count} webservers."
+    end
+  end
+  
+  desc <<-DESC
+    Set up a new webserver on a given VPS. Automatically installs and
+    configures the necessary software, running as its own UNIX user for
+    security purposes.
+    
+    Environment variables:
+      (optional) $ON: hostname of the VPS to set up the webserver onto.
+                      Default: the newest VPS.
+  DESC
+  task :setup do
+    vps = particular_vps || VPS.last
+    webserver = vps.webservers.build
+    
+    try_save webserver do
+      puts_title "Request sent"
+      puts "Webserver successfully scheduled for setup on VPS #{q vps}."
+    end
+  end
+  
+  desc <<-DESC
+    Force the setup procedure of a webserver to be re-run. You might want to
+    do that if you think you messed up the automatic configuration, UNIX
+    account or software installations.
+    
+    Environment variables:
+      (optional) $ID: the ID of the webserver (get the list with #{qcommand "webserver:list"}).
+                      Default: the webserver last set up.
+  DESC
+  task :reprepare do
+    fetch_current.put(:reprepare)
+    puts_title "Request sent"
+    puts "Webserver has been scheduled for re-preparation."
+  end
+  
+  desc <<-DESC
+    Force the reconfiguration of a webserver. You might want to do that if you
+    think you messed up the automatic configuration.
+    
+    Environment variables:
+      (optional) $ID: the ID of the webserver (get the list with #{qcommand "webserver:list"}).
+                      Default: the webserver last set up.
+  DESC
+  task :reconfigure do
+    fetch_current.put(:reconfigure)
+    puts_title "Request sent"
+    puts "Webserver has been scheduled for re-configuration."
+  end
+  
+  desc <<-DESC
+    List all websites hosted by a given webserver. That is, websites served
+    via the webserver by having one of their backends running on the same VPS
+    as the webserver.
+    
+    Environment variables:
+      $ID: the ID of the webserver (get the list with #{qcommand "webserver:list"}).
+  DESC
+  task :hosted do
+    webserver = fetch_current!
+    
+    puts_title "Hosted websites"
+    top.website.backends.show_list(webserver.backends.all)
+  end
+  
+  desc <<-DESC
+    Remove a webserver. This is accomplished by stopping all services run as
+    the UNIX user of the webserver, and then suppressing that user.
+    
+    No data is lost: as with any automated suppression of a UNIX user, the
+    home folder is backed up at /home/_foo, where "foo" is the name newly
+    suppressed user.
+    
+    The removal of a webserver is only allowed once all the backends of the
+    sites it serves have been removed (or switched webservers by way of
+    removal followed by re-creation). Get the list of all these remaining
+    backends with #{qcommand "webserver:hosted"}.
+    
+    Environment variables:
+      $ID: the ID of the webserver (get the list with #{qcommand "webserver:list"}).
+  DESC
+  task :remove do
+    webserver = fetch_current!
+    
+    begin
+      webserver.destroy
+    rescue WebService::ResourceConflict
+      error! $!.response.data['errors']
+    else
+      puts_title "Request sent"
+      puts "Webserver on VPS #{q webserver.vps} has been scheduled for removal."
+    end
+  end
+  
+  def require_id!
+    ENV["ID"] or
+      error! <<-MSG
+        The ID of the webserver to deal with must be specified by setting the
+        $ID environment variable. To list all webservers, run
+        #{qcommand "webserver:list"}.
+      MSG
+  end
+  
+  def fetch_current
+    particular_webserver || Webserver.last
+  end
+  
+  def fetch_current!
+    id = require_id!
+    Webserver.find(id)
+  end
+  
+  def particular_vps
+    VPS.find(ENV["ON"]) if ENV["ON"]
+  end
+  
+  def particular_webserver
+    Webserver.find(ENV["ID"]) if ENV["ID"]
+  end
+  
+  def particular_set_of_webservers
+    vps = particular_vps and vps.webservers
+  end
+end

data/lib/flucti/tasks/website/apptype_tasks.rb

@@ -0,0 +1,42 @@
+namespace :website do
+  namespace :apptype do
+    desc <<-DESC
+      Change the application type of the website in the current working
+      directory.
+      
+      When declaring a website, a type is (automatically or explicitely)
+      assigned to it. It is possible to change that initial choice with this
+      task:
+        $ cd path/to/foo
+        $ #{command "website:apptype:switch"} ID=custom
+        $ #{command "website:backends:reprepare"}
+      
+      Environment variables:
+        $ID: the ID or short name of the application type to switch to.
+    DESC
+    task :switch do
+      website, type_id = fetch_current!, require_id!
+    
+      website.app_type = AppType.find(type_id)
+    
+      try_save website do
+        puts_title "Application type switched"
+        puts_long <<-MSG
+          * The application type of website #{q website} has been successfully
+            switched to #{q website.app_type}.
+          
+          * Remember to re-reprepare all backends with
+            #{qcommand "website:backends:reprepare"}.
+        MSG
+      end
+    end
+  
+    def require_id!
+      ENV["ID"] || ENV["TO"] or
+        error! <<-MSG
+          The ID or short name of the application type to switch to must be
+          specified by setting the $ID environment variable.
+        MSG
+    end
+  end
+end

data/lib/flucti/tasks/website/backends/instances_tasks.rb

@@ -0,0 +1,37 @@
+namespace :website do
+  namespace :backends do
+    namespace :instances do
+      environment_variables = <<-EOS
+        Environment variables:
+          (optional) $ID: the ID of the backend to alter.
+                          Default: the backend last added.
+      EOS
+      
+      desc <<-DESC
+        Bump up the number of instances a backend. This adds one more process to
+        the backend, allowing for processing more requests per second, but also
+        consuming more memory.
+
+        The default is 1. This tasks increments the current number by 1.
+
+#{environment_variables}
+      DESC
+      task :more do
+        backend = backends.fetch_current
+        backend.post(:instances)
+        puts "Number of instances of backend #{backend} scheduled for increase."
+      end
+
+      desc <<-DESC
+        Decrease the number of instances of a backend.
+
+#{environment_variables}
+      DESC
+      task :less do
+        backend = backends.fetch_current
+        backend.delete(:instances)
+        puts "Number of instances of backend #{backend} scheduled for decrease."
+      end
+    end
+  end
+end

data/lib/flucti/tasks/website/backends_tasks.rb

@@ -0,0 +1,254 @@
+namespace :website do
+  namespace :backends do
+    # Allow for defining tasks named `test' and `try':
+    class << self
+      undef_method :test  if private_method_defined? :test
+      undef_method :try   if public_method_defined? :try
+    end
+    
+    task(:default) { list }
+    import_pack(:connect, self, "backend")
+    
+    desc <<-DESC
+      List all the backends currently running the site.
+    DESC
+    task :list do
+      site = website.fetch_current!
+      
+      puts_title "Backends of website: #{site}"
+      show_list(site.backends.all)
+    end
+    
+    desc <<-DESC
+      Prepare a VPS for hosting the current website. So is done by creating a
+      dedicated UNIX user to run the site as, enclosing processes related to
+      the site in a tight, secure environment. This prevents potential
+      security flaws to have an impact on other services run within the same
+      VPS.
+
+      Environment variables:
+        (optional) $ON: hostname of the VPS. Default: last webserver set up.
+        (optional) $AS: UNIX account to run the services as. Default: the
+                        name of the website.
+    DESC
+    task :add do
+      site = website.fetch_current!
+
+      unless webserver = (ENV["ON"] ? (vps = VPS.find(ENV["ON"])).webservers : Webserver).last
+        message = vps ? "No webserver seems to be running on VPS #{q vps}." : "You have no webserver set up yet."
+        message << " Set one up first by running #{qcommand "webserver:setup"}."
+        error! message
+      end
+
+      # Backend: ties together the site to the webserver
+      backend = site.backends.build(:webserver => webserver, :user => ENV["AS"])
+
+      try_save backend do
+        puts_title "Request sent"
+        puts_long <<-INFO
+          * A new backend for website #{q site} has been scheduled for setup
+            on VPS #{q backend.vps}.
+          
+          * If you are using an automatically generated Capfile, you should
+            download an updated version with #{qcommand "website:capfile:download"}.
+          
+          * Once the new backend is ready (check that #{qcommand "progress"}
+            is at 100%), you should re-deploy to push the site to it. If you
+            are using a Capfile, this is done with #{q "cap deploy:setup"}
+            followed by #{q "cap deploy"}.
+        INFO
+      end
+    end
+    
+    desc <<-DESC
+      Force a re-configuration of a backend. Checks the UNIX user,
+      re-generates configuration files and reloads the webserver's
+      configuration if necessary.
+      
+      Environment variables:
+        (optional) $ID: the ID of a particular backend (get the list with
+                        #{qcommand "website:backends:list"}).
+                        
+                        Default: all backends of the current websites are
+                        scheduled for reconfiguration.
+    DESC
+    task :reconfigure do
+      backends = fetch_several
+      
+      puts_title "Sending requests"
+      backends.each do |backend|
+        backend.put(:reconfigure)
+        puts "Backend #{backend} has been scheduled for reconfiguration."
+      end
+    end
+    
+    desc <<-DESC
+      Force a re-preparation of a backend.
+      
+      This re-runs the whole preparation process that was performed at
+      addition time. It's necessary to perform the preparation again when
+      switching application types of a website. For example:
+        $ cd path/to/foo
+        $ #{command "website:apptype:switch"} ID=custom
+        $ #{command "website:backends:reprepare"}
+    DESC
+    task :reprepare do
+      backends = fetch_several
+      
+      puts_title "Sending requests"
+      backends.each do |backend|
+        backend.put(:reprepare)
+        puts "Backend #{backend} has been scheduled for re-preparation."
+      end
+    end
+    
+    task :test do
+      backend = fetch_current
+      execute = lambda { |command| top.webserver.connect.ssh_details_for(webserver).execute(command) }
+      
+      # Check for errors during installations
+      puts_title "Installations"
+      none, display = true, lambda do |error, script_name|
+        begin
+          error = backend.send(error)
+          puts_subtitle "Error while executing #{q script_name}"
+          puts error.output
+        rescue WebService::ResourceNotFound
+          # ignore
+        else
+          none = false
+        end
+      end
+      display[:root_install_error, 'root_install.sh']
+      display[:install_error, 'install.sh']
+      puts "No error occured during installations." if none
+      
+      # Check syntax of webserver configuration file
+      puts_title "Webserver configuration"
+      webserver = backend.webserver
+      command = "/usr/sbin/nginx -c $HOME/webserver/nginx_main.conf -t"
+      top.webserver.connect.ssh_details_for(webserver).execute(command)
+      
+      # Fetch the home page locally
+      puts_title "Home page (beginning)"
+      command = "wget -q -O - localhost:#{backend.port} | head -15"
+      top.website.backends.connect.ssh_details_for(backend).execute(command)
+    end
+    
+    desc <<-DESC
+      Detect errors on service startup. Try to run the service script
+      (*_start.sh of the app. type) like the service manager would, in order
+      to spot errors output during startup, that would otherwise land in an
+      error log. Eases the task of debugging why an application progress
+      won't start like when forgetting to install a necessary RubyGem.
+      
+      Environment variables:
+        (optional) $ID: the ID of the backend to try to start the service within.
+                        Default: the backend last added.
+    DESC
+    task :try do
+      backend = fetch_current
+      
+      if type = backend.website.app_type
+        type.service_configs.each do |service|
+          run = lambda { |cmd| connect.ssh_details_for(backend).execute(cmd) }
+          
+          # Display service status
+          dir = "$HOME/service/#{backend.website.name}-#{service.name}-1"
+          run["sv status #{dir}"]
+          
+          # Try to start the service in the foreground to spot errors on startup
+          command = "#{dir}/run"
+          command = "p=$$; ((sleep 2; kill $p) &); #{command}"  # timeout
+          run[command]
+        end
+      end
+    end
+    
+    desc <<-DESC
+      Stop a backend and clear site-related files in a soft way.
+      
+      All the files related to the associated website are not deleted, but
+      instead moved in a backup directory in the home folder of the backends's
+      UNIX account.
+      
+      This UNIX account is then soft-cleared in a similar fashion. That is, it
+      is unregistered from the system, and its files are moved to a backup
+      directory under /home.
+      
+      Example backup directory for a backend running as "foo":
+        /home/_foo
+      
+      Example backup directory for a website named "bar" on this backend:
+        /home/_foo/_bar
+      
+      That way, the VPS is kept in a clean state, and your files are still
+      available for you to get them back if you need them. This would most
+      likely be the case if the site accepts uploads stored on the filesystem,
+      in a subdirectory of the site's root, like RAILS_ROOT/public/images/ for
+      a Rails application, or wp-content/ for a WordPress blog.
+      
+      Environment variables:
+        $ID: the ID of the backend to remove.
+    DESC
+    task :remove do
+      id = require_id!
+      
+      website = top.website.fetch_current!
+      backend = website.backends.find(id)
+      
+      if website.backends.all.size <= 1
+        confirm <<-WARN
+          You are about to remove the only backend left for this website. If
+          you do proceed with the removal, the site will become offline until
+          you set up a new one with #{qcommand "website:backends:add"} and
+          re-deploy.
+        WARN
+      end
+      
+      backend.destroy
+      
+      puts_title "Request sent"
+      puts_long <<-INFO
+        * Backend #{backend} has been scheduled for removal.
+        
+        * If you are using the automatically generated Capfile, you should
+          download the updated version with #{qcommand "website:capfile:download"}.
+      INFO
+    end
+    
+    def require_id!
+      ENV["ID"] or
+        error! <<-MSG
+          The ID of the backend to deal with must be specified by setting the
+          $ID environment variable. To list all backends of the current
+          website, run #{qcommand "website:backends"}.
+        MSG
+    end
+    
+    def fetch_current!
+      id = require_id!
+      website.fetch_current!.backends.find(id)
+    end
+    
+    def fetch_current
+      backends = website.fetch_current!.backends
+      (id = ENV["ID"]) ? backends.find(id) : backends.last
+    end
+    
+    def fetch_several
+      backends = website.fetch_current!.backends
+      (id = ENV["ID"]) ? [backends.find(id)] : backends.all
+    end
+    
+    def show_list(backends)
+      puts_list backends do |t|
+        t.col("Website") { |b| b.website.name }
+        t.col("Running on", :vps)
+        t.col("Running as", :user)
+        t.col("Instances", :num_instances)
+        t.col("Internal web port", :port)
+      end
+    end
+  end
+end