stackfu 0.1.0

data/lib/stackfu/commands/config_command.rb

@@ -0,0 +1,43 @@
+module StackFu
+  class ConfigCommand < Command
+    include StackFu::ApiHooks
+    include StackFu::ProvidersCredentials
+    
+    def default(parameters, options)
+      while true
+        login = options[:login] || ask("StackFu Login: ")
+        token = options[:token] || ask("StackFu Token: ")
+      
+        break if options[:login] and options[:token]
+        
+        puts ""
+        break if agree("Is this information correct? ", true)
+        puts ""
+        puts "OK, let's try it again"
+        puts ""
+      end
+    
+      puts ""
+      puts "Configuration saved to #{ENV['HOME']}/.stackfu"
+      save_config(login, token)
+    end
+    
+    def webbynode(parameters, options)
+      user = spinner { User.find(:all).first }
+      add_webbynode_credentials(user)
+    end
+  
+    def slicehost(parameters, options)
+      user = spinner { User.find(:all).first }
+      add_slicehost_credentials(user)
+    end
+  
+    private
+  
+    def save_config(login, token)
+      File.open("#{ENV["HOME"]}/.stackfu", "w") do |file|
+        YAML.dump({ :login => login, :token => token }, file)
+      end
+    end
+  end
+end

data/lib/stackfu/commands/deploy_command.rb

@@ -0,0 +1,144 @@
+module StackFu
+  class DeployCommand < Command
+    include ApiHooks
+  
+    error_messages :missing_subcommand => "You have to tell what you want to deploy (a stack or a plugin) and to which server."
+
+    subcommand :plugin, :required_parameters => [:plugin_name, :server]
+    subcommand :stack,  :required_parameters => [:stack_name, :server]
+
+    def plugin(parameters, options)
+      execute "plugin", parameters, options, false do |target|
+        puts "*** Preparing: #{target.name.foreground(:yellow).bright}"
+        puts "    #{target.description}"
+        puts ""
+      end
+    end
+    
+    def stack(parameters, options)
+      execute "stack", parameters, options, true do |target|
+        puts "*** Deploying: #{target.name.foreground(:yellow).bright} (based on #{os_name(target.operating_system.to_sym).foreground(:yellow)})"
+        puts "    #{target.description}"
+        puts ""
+      end
+    end
+
+    private
+    
+    def extract_settings(target)
+      target_name = parameters[0]
+      server_name = parameters[1]      
+      
+      target_class = StackFu::ApiHooks.const_get(target.capitalize)
+      
+      targets = target_class.find(:all, :params => { target.to_sym => { :name => target_name } })
+      unless targets.any?
+        error "#{target.capitalize} '#{target_name}' was not found"
+        return
+      end
+      
+      server = Server.find(:all, :params => { :server => { :hostname => server_name } })
+      unless server.any?
+        error "Server '#{server_name}' was not found.",
+          "You can add servers 'stackfu server add' or list your current servers with 'stackfu servers'."
+        return
+      end
+      
+      return targets.first, server
+    end
+    
+    def execute(target_name, parameters, options, stack)
+      target, server = extract_settings(target_name)
+      return unless target
+      
+      yield target
+      
+      params = fill_values_from_options(target, options)
+      names = target.controls.map(&:name)
+      review = params.any?
+      
+      if (names - params.keys.map(&:to_s)).any?
+        puts "Please configure your deployment by answering the configuration settings below."
+        puts ""
+
+        params = render_target(params, target, options)
+        
+        puts ""
+      end
+      
+      # We'll only show a review if > 1 item was not collected from console
+      if review
+        max_length = target.controls.map { |c| c.label.size }.max
+        
+        puts "Please review the configuration for your deployment:"
+        puts ""
+        target.controls.each do |c|
+          puts "  #{c.label.rjust(max_length).foreground(:yellow)}#{":".foreground(:yellow)} #{params[c.name]}"
+        end
+        puts ""
+      end
+    
+      continue = if stack
+        warning "This will destroy current contents of your server. Are you sure?\n"
+      else
+        agree "Continue with plugin installation?\n"
+      end
+      
+      unless continue
+        puts "Aborted."
+        return false
+      end
+    
+      item = target if stack
+      hash = { :stack => item, :server_id => server.first.id, :params => params }
+      
+      unless stack
+        hash[:plugin_ids] = [target.id]
+      end
+      
+      deployment = Deployment.new(hash)
+      
+      unless deployment.save
+        error "There was a problem submitting your deployment: #{deployment.errors.full_messages.to_s}"
+        return
+      end
+    
+      if options[:"no-follow"]
+        puts "Your deployment have been submitted"
+        return 
+      end
+    
+      verbose = options[:verbose]
+    
+      from = nil
+      while true
+        opts = {:formatted => "true", :from => from}
+        opts.merge!(:verbose => "true") if verbose
+
+        status = spinner {
+          Deployment.find(deployment.id).get(:logs, opts)
+        }
+      
+        if status["id"]
+          show_log status["log"]
+          from = status["id"] 
+        end
+
+        break if status["state"] == "finished" or status["state"] == "failed"
+      end
+      
+    end
+  
+    def show_log(logs)
+      logs.each do |s|
+        if s =~ /^  \[stdout\]/
+          puts s.chop.gsub("  [stdout] ", "").gsub(/^/, "  ").foreground(:yellow)
+        elsif s =~ /^  \[stderr\]/
+          puts s.chop.gsub("  [stderr] ", "").gsub(/^/, "  ").foreground(:red)
+        else
+          puts s
+        end
+      end
+    end
+  end
+end

data/lib/stackfu/commands/dump_command.rb

@@ -0,0 +1,101 @@
+module StackFu
+  class DumpCommand < Command
+    include ApiHooks
+
+    error_messages :missing_subcommand => "You have to tell what you want to dump: a stack or a plugin"
+    subcommand :stack, :required_parameters => [:stack_name]
+    
+    def stack(parameters, options)
+      stack_name = parameters[0]
+      stack = spinner { Stack.find(:all, :params => { :stack => { :name => stack_name } }).first }
+      
+      if stack
+        if directory?(stack_name) 
+          unless agree("There is already a folder called '#{stack_name}'. Do you want to overwrite its contents?")
+            puts "Aborted."
+            return false
+          end
+        end
+        
+        create_folder(stack_name)
+        create_file "#{stack_name}/stack.yml", {
+          "type" => "stack",
+          "name" => stack.name,
+          "description" => stack.description,
+          "operating_system" => stack.operating_system.to_s
+        }.to_yaml
+        
+        create_folder "#{stack_name}/config"
+        
+        controls = map stack.controls, "controls" do |c|
+          { "name"  => c.name,
+            "label" => c.label,
+            "type"  => c._type }
+        end
+        
+        requirements = map stack.requirements, "requirements" do |req|
+          { "data"  => req.data,
+            "error" => req.error,
+            "type"  => req._type }
+        end
+        
+        executions = map stack.executions, "scripts" do |exec|
+          { "description" => exec.description,
+            "file"        => exec.description.downcase.gsub(" ", "_") }
+        end
+        
+        validations = map stack.validations, "validations" do |val|
+          { "data"  => val.data,
+            "error" => val.error,
+            "type"  => val._type }
+        end
+        
+        create_file "#{stack_name}/config/01-controls.yml", controls
+        create_file "#{stack_name}/config/02-requirements.yml", requirements
+        create_file "#{stack_name}/config/03-scripts.yml", executions
+        create_file "#{stack_name}/config/04-validations.yml", validations
+        
+        create_folder "#{stack_name}/script"
+        stack.executions.each do |script|
+          create_file "#{stack_name}/script/#{script.description.downcase.gsub(" ", "_")}.sh.erb", script.data
+        end
+        
+        puts "Stack #{stack_name} dumped successfully..."
+      else
+        puts "Stack '#{stack_name}' was not found"
+      end
+    end
+    
+    private
+    
+    def directory?(folder)
+      File.directory?(folder)
+    end
+    
+    def map(collection, name)
+      { name => collection.map { |item| yield item } }.to_yaml
+    end
+    
+    def create_folder(folder)
+      puts "\tcreate  #{folder}/"
+      mkdir folder
+    end
+    
+    def mkdir(folder)
+      unless File.directory?(folder)
+        Dir.mkdir folder
+      end
+    end
+    
+    def create_file(file, contents)
+      puts "\tcreate  #{file}"
+      write_file(file, contents)
+    end
+    
+    def write_file(file, contents)
+      File.open(file, "w") do |file|
+        file.write(contents)
+      end      
+    end
+  end
+end

data/lib/stackfu/commands/generate_command.rb

@@ -0,0 +1,107 @@
+require 'erb'
+require 'ostruct'
+
+module StackFu
+  class GenerateCommand < Command
+    aliases :create
+    subcommand :stack, :required_parameters => [:stack_name]
+    subcommand :plugin, :required_parameters => [:plugin_name]
+    error_messages :missing_subcommand => "You have to tell what you want to generate: a stack or a plugin."
+  
+    Types = { 
+      [:checkbox, :numericbox, :combobox, :password, :radio, :textbox] => :control
+    }
+
+    def type(t)
+      return :unknown unless t
+    
+      ctrl = t.to_sym
+      Types.each_pair do |key, value|
+        ctrl = value if key.include?(ctrl)
+      end
+      ctrl
+    end
+    
+    def plugin(parameters, options)
+      generate("plugin", parameters, options)
+    end
+    
+    def stack(parameters, options)
+      generate("stack", parameters, options)
+    end
+  
+    def generate(what, parameters, options)
+      begin
+        item_name = parameters.shift
+        items = {}
+        while (p = parameters.shift)
+          name, type = p.split(":")
+        
+          case type(type)
+          when :script
+            (items["scripts"]||=[]) << [name, template("script.sh.erb", {
+              "filename" => name,
+              "description" => name.titleize
+            })]
+          
+          when :control
+            (items["controls"]||=[]) << [name, type]
+          
+          else
+            raise Exceptions::InvalidParameter, 
+              "Don't know how to generate a #{what} with #{type ? "#{type} " : ""}#{name}. Use 'stackfu help generate' for more information."
+          
+          end
+        end
+      
+        stack = template("stack.yml.erb", {
+          "name" => item_name,
+          "description" => "Enter a description for this stack here"
+        })
+      
+        create("#{item_name}", "#{what}.yml", stack)
+
+        i = 1
+        %w[controls requirements scripts validations].each do |item|
+          template_name = "0#{i}-#{item}.yml"
+          create "#{item_name}/config", template_name, template("#{template_name}.erb", {
+            item => items[item]
+          })
+          i += 1
+        end
+    
+        items["scripts"].try(:each) do |item|
+          create("#{item_name}/script", "#{item.first}.sh.erb", item.last)
+        end or create("#{item_name}/script")
+      
+        puts "#{what.titleize} #{item_name} created successfully"
+      rescue Exceptions::InvalidParameter
+        puts $!.message
+      rescue IOError, Errno::EEXIST
+        puts "There was an error creating your #{what}: #{$!.message}"      
+      end
+    end
+  
+    private
+  
+    def template(t, vars)
+      file = "#{File.dirname(__FILE__)}/../../../templates/#{t}"
+      ERB.new(File.open(file, "r").readlines.join("")).result(OpenStruct.new(vars).send(:binding))
+    end
+  
+    def create(d, f=nil, contents=nil)
+      unless File.directory?(d)
+        puts "\tcreate  #{d}/"
+        ::FileUtils.mkdir_p(d)
+      end
+
+      if f.present?
+        f = "#{d}/#{f}"
+        puts "\tcreate  #{f}"
+        File.open(f, "w") do |file|
+          file.write(contents)
+        end
+      end
+    end
+  end
+end

data/lib/stackfu/commands/help_command.rb

@@ -0,0 +1,28 @@
+module StackFu
+  class HelpCommand < Command
+    def default(parameters, options)
+      stackfu = "stackfu".foreground(:green).bright
+    
+      puts "#{"StackFu #{StackFu::VERSION}".foreground(:green).bright}, a server deployment manager."
+      puts " (c) 2009-2020 StackFu - http://stackfu.com"
+      puts ""
+      puts "  Usage:"
+      puts "    #{stackfu} #{"command".foreground(:cyan)} [arguments...] [options...]"
+      puts ""
+      puts "  Examples:"
+      puts "    #{stackfu} #{"generate".foreground(:cyan)} stack lamp"
+      puts "    #{stackfu} #{"pub".foreground(:cyan)}"
+      puts "    #{stackfu} #{"deploy".foreground(:cyan)} lamp server1"
+      puts ""
+      puts "  Commands:"
+      puts "    #{"help".foreground(:cyan)}                         you already know about this one, dontcha?"
+      puts "    #{"config".foreground(:cyan)}                       configure StackFu CLI options"
+      puts "    #{"server".foreground(:cyan)}                       create, delete, update and deploy to StackFu servers"
+      puts "    #{"generate".foreground(:cyan)} [stack|plugin]      creates a new stack or plugin in current_dir/name"
+      puts "    #{"publish".foreground(:cyan)}                      publishes the item on the current folder to StackFu.com"
+      puts "" 
+      puts "  For a complete guide on using StackFu from command line:"
+      puts "    #{"http://stackfu.com/guides/stackfu-cli".underline}"
+    end
+  end
+end

data/lib/stackfu/commands/list_command.rb

@@ -0,0 +1,26 @@
+module StackFu
+  class ListCommand < Command
+    include ApiHooks
+  
+    def default(parameters, options)
+      user = User.find(:all).first
+      items = spinner { 
+        [
+          Stack.find(:all, :conditions => { "user.id" => user.id }), 
+          Plugin.find(:all, :conditions => { "user.id" => user.id })
+        ].flatten
+      }
+      
+      params = {
+        :class => [Stack, Plugin], 
+        :collection => items,
+        :display => [:name, :type, :description],
+        :main_column => :name,
+        :empty => "You have nothing to list yet. To generate stacks or plugins, try the 'stackfu generate' command.",
+        :ansi => options[:plain].nil?
+      }
+
+      puts table(params) { |item| [item.name, item.class.name.demodulize.downcase, item.description.try(:truncate_words)] }
+    end
+  end
+end

data/lib/stackfu/commands/publish_command.rb

@@ -0,0 +1,108 @@
+module StackFu
+  class PublishCommand < Command
+    include ApiHooks
+    aliases :pub
+    
+    def stack?
+      File.exists?("stack.yml")
+    end
+    
+    def plugin?
+      File.exists?("plugin.yml")
+    end
+
+    def default(parameters, options)
+      what = :stack if stack?
+      what = :plugin if plugin?
+      
+      unless what
+        error "Couldn't find an item to publish on current folder.",
+          "Make sure you have a file named 'stack.yml', 'plugin.yml' or use 'stackfu generate' for creating a new stack."
+      end
+      
+      begin
+        stack_spec = YAML.load(read("#{what}.yml"))
+      
+        %w[controls requirements scripts validations].each_with_index do |item, i|
+          if (yaml = read("config/0#{i+1}-#{item}.yml"))
+            yaml.gsub!("type:", "_type:") if item == "controls"
+            if (from_yaml = YAML.load(yaml))
+              stack_spec[item == "scripts" ? "executions" : item] = from_yaml[item]
+            end
+          end
+        end
+      
+        unless stack_spec["executions"].present?
+          error "To publish a #{what} you have to define at least one script.",
+            "Take a look at the scripts descriptor file config/03-script.yml for more information.\nYou can also use 'stackfu generate stack_name script_name:script' command to auto-generate a sample script."
+          return false
+        end
+      
+        return unless stack_spec["executions"].each do |script|
+          template = "script/#{script["file"]}.sh.erb"
+        
+          begin
+            script["script"] = read(template)
+          rescue Errno::ENOENT
+            error "The template file for the script '#{script["description"]}' was not found.", "This stack has a script called '#{script["description"]}', and the template for it should be in a file called script/#{script["file"]}.sh.erb."
+            break false
+          end
+        
+          true
+        end
+        
+        item_class = ApiHooks.const_get("#{what.to_s.classify}")
+
+        stacks = item_class.find(:all, :params => { what => { :name => stack_spec["name"] } })
+        if stacks.any? 
+          unless options[:update]
+            if agree("You already have a #{what} named #{stack_spec["name"]}. Do you want to update it?")
+              puts ""
+              puts "Tip: Next time you can avoid this question using 'stack pub --update'."
+              puts ""
+            else
+              puts "Aborted."
+              return false
+            end
+          end
+        
+          stack = stacks.first
+          begin
+            item_class.delete(stack.id)
+          rescue ActiveResource::ResourceNotFound 
+            puts "There was a problem updating your #{what}. Please report this problem at support@stackfu.com or try again in a few minutes."
+            return
+          end
+        end
+      
+        puts "Publishing #{what} #{stack_spec["name"]}..."
+
+        stack = item_class.new(stack_spec)
+        if publish(stack)
+          done "#{what.to_s.titleize} #{stack.name} published."
+        else
+          error "Could not publish your stack: #{stack.errors.full_messages.to_s}"
+        end
+      rescue ActiveResource::ServerError
+        error "#{$!.message}"
+      rescue Errno::ENOENT
+        error "There was an error opening your file descriptor"
+      end
+    end
+  
+    private
+  
+    def publish(stack)
+      spinner {
+        stack.save
+      }
+    end
+  
+    def read(file)
+      File.open(file, "r").readlines.join("")
+    end
+  
+    def load_stack
+    end
+  end
+end

data/lib/stackfu/commands/server_command.rb

@@ -0,0 +1,124 @@
+module StackFu
+  class ServerCommand < Command
+    include StackFu::ApiHooks
+    include StackFu::ProvidersCredentials
+
+    aliases :servers
+  
+    alias_subcommand :list => :default
+    # subcommand :add, :required_parameters => [:provider, :server_name]
+    subcommand :delete, :required_parameters => [:server_name]
+
+    def default(parameters, options)
+      servers = spinner {
+        Server.find(:all)
+      }
+
+      params = {
+        :class => Server, 
+        :collection => servers, 
+        :display => [:hostname, :provider_class, :ip, :status],
+        :labels => { :hostname => "Name", :provider_class => "Provider", :ip => "IP", :status => "Status" },
+        :main_column => :hostname,
+        :empty => "You have no servers under your account. Try adding some with 'server add' command.",
+        :ansi => options[:plain].nil?
+      }
+    
+      puts table(params) { |item| [item.hostname, item.provider_class, item.ip, item.status ? item.status[0] : ""] }
+    end
+  
+    def delete(parameters, options)
+      # TODO more than one server with the same hostname
+      spinner {
+        server = Server.find(:all).select { |s| s.hostname == parameters[0] }.first
+        server.destroy
+      }
+    
+      puts "Server #{parameters[0]} deleted successfully"
+    end
+
+    def add(parameters, options)
+      if params?
+        if parameters.size < 2
+          puts "The command #{"server add".to_s.foreground(:yellow)} requires 2 parameters.\nUsage: stackfu server add PROVIDER SERVER_NAME"
+          return false
+        end
+        provider = parameters[0]
+        server_name = parameters[1]
+                
+        user = User.find(:all).first
+        return false unless send("check_#{provider.downcase}", user)
+      else
+        server_add_header
+      end
+    
+      unless params?
+        provider, server_name = *server_menu
+      end
+    
+      server = Server.new(:provider_class => provider, :hostname => server_name)
+      result = spinner {
+        server.save
+      }
+    
+      puts " "
+      if result
+        puts "Server #{server_name} added successfully."
+      else
+        puts " "
+        puts "Server #{server_name} couldn't be added. Here's the error we've got:\n#{server.errors.full_messages.to_s}"
+      end
+    end
+  
+    private
+    
+    def check_slicehost(user)
+      unless user.settings.respond_to?(:slicehost_token)
+        return false unless add_slicehost_credentials(user)
+      end
+      
+      return true
+    end
+  
+    def check_webbynode(user)
+      unless user.settings.respond_to?(:webbynode_login) and user.settings.respond_to?(:webbynode_token) 
+        return false unless add_webbynode_credentials(user)
+      end
+      
+      return true
+    end
+  
+    def server_add_header
+      puts "=== Add Server ===".foreground(:green).bright
+    end
+  
+    def server_menu
+      user = User.find(:all).first
+
+      providers = spinner { Provider.find(:all) }
+      provider_id = menu_for("provider", providers, true)
+    
+      provider = providers.select { |p| p.id == provider_id }.first
+    
+      puts ""
+      puts "Provider: #{provider_id.foreground(:blue)}"
+      puts ""
+      
+      return false unless send("check_#{provider_id.downcase}", user)
+
+      servers = spinner { provider.get(:servers).to_structs }
+      server = menu_for("server", servers)
+    
+      puts ""
+      puts "Adding server #{server.foreground(:blue)}..."
+    
+      [provider_id.titleize, server]
+    end
+  
+    def slicehost
+      spinner {
+        UserAccount.find(:conditions => { :provider => "Slicehost" }).servers
+      }
+    end
+  end
+end