Flucti-flucti-cli 0.1.16

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

@@ -0,0 +1,41 @@
+namespace :website do
+  namespace :capfile do
+    DESTINATION = "Capfile"
+    
+    task(:default) { show }
+    
+    desc <<-DESC
+      Display the content of latest Capfile without downloading it.
+    DESC
+    task :show do
+      site = website.fetch_current
+      puts_title "Capfile for site: #{site}"
+      puts site.get("/capfile.rb")
+    end
+    
+    desc <<-DESC
+      Download the latest Capfile for the current website.
+    DESC
+    task :download do
+      if File.exist?(DESTINATION) && !File.read(DESTINATION).blank?
+        puts_title "Backing up previous Capfile"
+        backup = Dir.tmpdir + "/#{File.basename DESTINATION}.#{Time.now.to_f}"
+        FileUtils.mv(DESTINATION, backup)
+        puts "Backup location: #{backup}"
+      end
+      puts_title "Downloading latest Capfile"
+      begin
+        File.open(DESTINATION, "w") do |f|
+          f.puts website.fetch_current!.get("/capfile.rb")
+        end
+        puts "Downloaded: %.2f KB" % [File.size(DESTINATION) / 1024.0]
+      rescue WebService::ResourceNotFound
+        puts "(No Capfile for the application type of the website.)"
+      end
+    end
+    
+    def downloaded?
+      File.file?(DESTINATION)
+    end
+  end
+end

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

@@ -0,0 +1,107 @@
+namespace :website do
+  namespace :domains do
+    desc <<-DESC
+      Attach a domain to the current website. This can be one of:
+      
+        * A domain of your own: setup instructions will be displayed after
+          successful attachment. For example: "foobar.com".
+      
+        * A free subdomain: choose one ending with ".flucti.com": immediately
+          available, setup required.
+          For example: "foobar.flucti.com".
+      
+        * A subdomain of either a domain of your own or a free subdomain.
+          For example: "blog.foobar.com" or "blog.foobar.flucti.com".
+      
+        * A wildcard subdomain.
+          For example: "*.foobar.com" or "*.foobar.flucti.com"
+      
+      Environment variables:
+        $DOMAIN: the domain name.
+    DESC
+    task :attach do
+      site = website.fetch_current!
+      name = require_name!
+      
+      domain = site.domains.build(:name => name)
+      
+      examples = []
+      try_save domain do
+        puts_title("Request sent")
+        puts_long <<-INFO
+          * Domain #{q domain} has been scheduled for attachment to website
+            #{q site}.
+        INFO
+        if domain.attribute_set?(:cname_domain_name)
+          puts
+          puts_long <<-INFO 
+            * For #{q domain} to point to your VPS's, you must go to your
+              registrar's control panel, clear any previous A or CNAME
+              records, and add a CNAME record to #{q domain.cname_domain_name}.
+          INFO
+        end
+      end
+    end
+    
+    desc "Alias for `attach'."
+    task(:add) { attach }
+    
+    desc <<-DESC
+      Detach a domain from the current website. By doing so, the website will
+      cease to be available at the specified domain.
+      
+      Environment variables:
+        $DOMAIN: the domain name.
+    DESC
+    task :detach do
+      site = website.fetch_current!
+      name = require_name!
+      
+      domain = site.domains.find(name)
+      domain.destroy
+      
+      puts_title("Request sent")
+      puts "Domain #{q domain} has been scheduled for detachment from website #{q site}."
+    end
+    
+    desc "Alias for `attach'."
+    task(:remove) { detach }
+    
+    desc <<-DESC
+      List all domains that need a CNAME record. In order for the domains you
+      own to point to the VPS hosting a site, you need to declare a CNAME
+      record on the DNS server of the domains, most likely managed by the
+      registrar they have been bought from.
+      
+      Please note that it can take up to 48 hours for the changes to
+      propagate.
+      
+      Free subdomains don't need such a declaration since they are handled on
+      our side. That is why they are not listed. As a consequence, they are
+      functional immediately.
+    DESC
+    task :cnames do
+      site = website.fetch_current!
+      
+      domains_with_cname = site.domains.select { |dom| dom.cname_domain_name }
+      
+      if domains_with_cname.any?
+        puts_list(domains_with_cname, :id => false, :table => true) do |t|
+          t.col("Domain", :name)
+          t.col("CNAME", :cname_domain_name)
+        end
+      else
+        puts "No domain needs to be declared CNAME records."
+      end
+    end
+    
+    def require_name!
+      ENV["DOMAIN"] or
+        error! <<-MSG
+          The domain name to deal with must be specified by setting the
+          $DOMAIN environment variable. To list all domains currently attached
+          to the current website, run #{qcommand "website"}.
+        MSG
+    end
+  end
+end

data/lib/flucti/tasks/website_tasks.rb

@@ -0,0 +1,221 @@
+namespace :website do
+  task(:default) { status }
+  
+  desc <<-DESC
+    List of all your declared websites.
+  DESC
+  task :list do
+    puts_title "Declared websites"
+    list_displayer.display(Website.all)
+  end
+  
+  desc <<-DESC
+    Display the names of all the declared websites. As opposed to
+    #{qcommand 'website:list'}, only the names are displayed, one name per
+    line. This is useful for batch processing.
+  DESC
+  task :names do
+    Website.all.each do |site|
+      puts(site.name)
+    end
+  end
+  
+  desc <<-DESC
+    Display the status of the current website. That is, whether it is declared
+    or not, and if it is, displays its details.
+  DESC
+  task :status do
+    site = fetch_current!
+    puts_title "Website in the current directory"
+    show(site, :include_status)
+  end
+  
+  desc "Alias for task `status'."
+  task(:show) { status }
+  
+  desc <<-DESC
+    Declare the current website for subsequent deploys. This is necessary for
+    the site to be made online. That is, for our routers to direct traffic to
+    and from your VPS's.
+    
+    Environment variables:
+      (optional) $SITEID: the name of the site for it to be referred to as later.
+                          Default: the name the current working directory.
+      
+      (optional) $TYPE:   the ID or short name of the corresponding application
+                          type (#{qcommand "apptype:list"} to see what stock
+                          app. types are available, or #{qcommand "apptype:push"}
+                          to create your own).
+  DESC
+  task :declare do
+    if site = fetch_current
+      puts "Already declared (as #{q site})"
+      next
+    end
+
+    # Find the application type
+    type =
+      if short = ENV["TYPE"]
+        AppType.all.find { |t| t.short == short } or
+          error! <<-MSG
+            Application type #{q short} does not exist. For a list of
+            available application types, run #{qcommand "apptype:list"}.
+          MSG
+      else
+        autodetect_app_type
+      end
+    
+    # Prepare site for declaration
+    site = Website.new  :name     => name_of_current,
+                        :app_type => type
+    
+    # Attempt to push the declaration to the server
+    try_save site do
+      puts_title "Site declared"
+      show(site)
+    
+      puts_subtitle("What to do next")
+      puts_long <<-INFO
+        1) Database connection:
+        -----------------------
+        If your site is database backed, and if you haven't done so already,
+        you should now set up a database server with #{qcommand \
+        "db:server:setup"} and modify the production database connection
+        settings accordingly in the configuration files (for example:
+        wp-config.php for a WordPress blog, config/database.yml for a Rails
+        application).
+        
+        2) Backends:
+        ------------
+        For your site to be online, webservers must receive requests from
+        visitors and turn to backend processes (typically PHP or Rails) to
+        process them. So there has to exist at least one webserver running,
+        and at least one backend on one of the webserver VPS's. Such an
+        architecture can be put in place by:
+        
+          * Setting up an initial, minimal stack, in an automated fashion:
+              $ #{command "website:ensure_deployable"}
+        
+          * or going through each step manually for finer grained control.
+            Example:
+              $ #{command "webserver:setup ON=felix"}
+              $ #{command "website:backends:add ON=felix"}
+        
+        The actions of whichever option you choose can be reverted or altered
+        later.
+        
+        3) Deployment:
+        --------------
+        To upload the files of your website to the backends, you can either:
+          
+          * Download and run an automatically generated recipe, in the form of
+            a Capfile:
+              $ #{command "website:capfile:download"}
+              $ cap deploy:setup deploy
+          
+          * Connect to each backend individually and upload the files to them.
+            For example:
+              $ #{command "website:backends:connect:details"}
+              $ scp -P 1025 -r * foo@bar.flucti.net:~/mysite/current
+        
+        5) Wait:
+        --------
+        Wait a few moments for all automated actions to finish, and then your
+        site should be online at http://#{site.domains.first}:
+          $ #{command "progress"}
+        
+        6) Domain:
+        ----------
+        The default domain that has been attached automatically to your site
+        can be replaced by attaching your actual domain with
+        #{qcommand("website:domains:attach")} and removing the default one
+        with #{qcommand("website:domains:detach")}.
+      INFO
+    end
+  end
+  
+  desc <<-DESC
+    Make sure the site can be deployed. For this to be the case, there has to
+    exist at least one webserver: one is set up if none is yet. Also, the
+    website has to be running on at least one of the VPS that run a webserver.
+    Failing that, the VPS with the webserver last set up is chosen as the
+    first host for the website. Those two parameters can be altered later.
+  DESC
+  task :ensure_deployable do
+    website = fetch_current!
+    
+    if (count = website.backends.all.size).zero?
+      webserver.ensure_any
+      backends.add
+    else
+      puts_title "Backends present"
+      puts "There exists #{count} backends."
+    end
+  end
+  
+  desc "Alias for task `website:backends:enter'."
+  task(:enter) { backends.enter }
+  
+  desc <<-DESC
+    Delete a website and all of its backends. This will take it offline and
+    soft-clear all files stored in the backends (see #{qcommand 'website:backends:remove'}).
+  DESC
+  task :delete do
+    site = fetch_current!
+    confirm <<-WARN
+      Deleting a website will make it will:
+      
+        * Cancel its declaration, making it unavailable.
+      
+        * Do the equivalent of #{qcommand "website:backends:remove"} for all the
+          backends, so be sure to read the documentation of this command
+          (#{qcommand '-e website:backends:remove'}) before confirming.
+    WARN
+    site.destroy
+    puts_title "Request sent"
+    puts "Website #{q site} scheduled for deletion."
+  end
+  
+  def name_of_current
+    ENV['SITEID'] || clean_name(Pathname.pwd.basename)
+  end
+  
+  def fetch_current
+    Website[name_of_current]
+  end
+  
+  def fetch_current!
+    fetch_current or
+      error! <<-MSG
+        The current website is undeclared yet (or at least not as
+        #{q name_of_current}). Run #{qcommand "website:declare"} to declare it.
+      MSG
+  end
+  
+  def autodetect_app_type
+    types = AppType.all.to_a
+    static = types.find { |t| t.short == 'static' }
+    (types - [static]).
+      sort_by { |t| %w(rails php).index(t.short) || -1 }.
+      each { |apptype|
+        if test = apptype.detection
+          filetype, path = test.split(' ', 2)
+          return apptype if Kernel.test(filetype, path)
+        end
+      }
+    static
+  end
+  
+  def show(site, *args)
+    list_displayer(*args).display_single_entry(site)
+  end
+  
+  def list_displayer(include_status=false)
+    Utilities::ListDisplayer.new(:title => :name) do |t|
+      t.col("Status") { "Declared" } if include_status
+      t.col("Name", :name)
+      t.col("Type", :app_type)
+      t.col("Domains") { |s| (domains = s.domains.to_a).any? ? domains * ', ' : '(none)' }
+    end
+  end
+end

data/lib/flucti/utilities.rb

@@ -0,0 +1,20 @@
+module Flucti
+  module Utilities
+    SUPPORT_EMAIL_ADDR = "support@flucti.com"
+  
+    autoload :CoreExt,        'flucti/utilities/core_ext'
+    autoload :UserInterface,  'flucti/utilities/user_interface'
+    autoload :TaskPacking,    'flucti/utilities/task_packing'
+    autoload :Miscellaneous,  'flucti/utilities/miscellaneous'
+    autoload :Table,          'flucti/utilities/table'
+    autoload :ListDisplayer,  'flucti/utilities/list_displayer'
+    autoload :ProgressBar,    'flucti/utilities/progress_bar'
+    autoload :ConnectionErrorHandling, 'flucti/utilities/connection_error_handling'
+  
+    include UserInterface
+    include TaskPacking
+    include Miscellaneous
+    
+    extend self
+  end
+end

data/lib/flucti/utilities/connection_error_handling.rb

@@ -0,0 +1,50 @@
+module Flucti
+  module Utilities
+    module ConnectionErrorHandling
+      def self.included(target)
+        target.module_eval do
+          alias_method_chain :request, 'exception_handling'
+        end
+      end
+
+      def request_with_exception_handling(*args, &block)
+        request_without_exception_handling(*args, &block)
+      rescue => e
+        Handler.handle(e) or raise e
+      end
+
+      module Handler
+        extend self, Utilities
+
+        def handle(err)
+          case err
+          when WebService::BadGateway
+            error! <<-MSG
+              The VPS you attempted to perform an action on returned an error.
+              It may be out of memory or disk space. Try running
+              #{qcommand 'vps:run CMD="vmstat -s -S M"'} and
+              #{qcommand 'vps:run CMD="df -h"'} respectively to determine
+              whether it's the case or not.
+            MSG
+          when WebService::ServiceUnavailable, WebService::TimeoutError, Errno::ECONNREFUSED
+            error! <<-MSG
+              It looks like we are currently performing maintenance on our
+              servers. Please retry later.
+            MSG
+          when WebService::GatewayTimeout
+            error! <<-MSG
+              The VPS you attempted to perform an action on did not respond in
+              time. Please check its system load averages and retry.
+            MSG
+          when WebService::ServerError
+            error! <<-MSG
+              An error occurred while processing your request. We have be
+              notified about this error and will work on fixing it. We
+              apologize for the inconvenience. Please retry later.
+            MSG
+          end
+        end
+      end
+    end
+  end
+end

data/lib/flucti/utilities/core_ext.rb

@@ -0,0 +1,35 @@
+module Flucti
+  module Utilities
+    module CoreExt
+      def self.apply!
+        # Proper version of #constantize, since ActiveSupport's behaves strangely.
+        String.class_eval do
+          def constantize
+            split('::').inject(Object) { |mod, name| mod.const_get(name) }
+          end
+        end
+
+        Pathname.class_eval do
+          alias_method :/, :+
+          protected :+
+        end
+
+        # Thorough version of `unhook!'.
+        ActiveSupport::Dependencies.unhook!
+        ActiveSupport::Dependencies::ClassConstMissing.module_eval do
+          def const_missing(*args)
+            super
+          end
+        end
+        
+        ActiveSupport::Inflector.inflections do |inflect|
+          inflect.singular('databases', 'database')
+        end
+
+        WebService::RemoteCollection.class_eval do
+          include ConnectionErrorHandling
+        end
+      end
+    end
+  end
+end