webbynode 0.1.2 → 0.2.0

data/lib/webbynode/commands/change_dns.rb

@@ -0,0 +1,29 @@
+module Webbynode::Commands
+  class ChangeDns < Webbynode::Command
+    requires_initialization!
+
+    summary "Changes the DNS entry for this application"
+    parameter :dns_entry, "New DNS entry for this application"
+    
+    add_alias "dns"
+    
+    def execute
+      raise CommandError, 
+        "Cannot change DNS because you have pending changes. Do a git commit or add changes to .gitignore." unless git.clean?
+      
+      io.log "Changing DNS to #{param(:dns_entry)}...", :quiet_start
+      
+      git.delete_file ".webbynode/config"
+      handle_dns param(:dns_entry)
+      
+      app_name = io.app_name
+      io.create_file(".pushand", "#! /bin/bash\nphd $0 #{app_name} #{param(:dns_entry)}\n", true)
+
+      git.add ".pushand"
+      git.add ".webbynode/settings" if io.file_exists?(".webbynode/settings")
+      git.commit "Changed DNS to \"#{param(:dns_entry)}\""
+
+      io.log "Your application will start responding to #{param(:dns_entry)} after next deployment."
+    end
+  end
+end

data/lib/webbynode/commands/config.rb

@@ -0,0 +1,15 @@
+module Webbynode::Commands
+  class Config < Webbynode::Command
+    summary "Adds or changes your Webbynode API credentials"
+    option :email, "The email you use on Webbymanager"
+    option :token, "The API Token, found on Account section of Webbymanager"
+    
+    def execute
+      value = {}
+      value[:email] = option(:email) if option(:email)
+      value[:token] = option(:token) if option(:token)
+      
+      api.init_credentials(value)
+    end
+  end
+end

data/lib/webbynode/commands/delete.rb

@@ -0,0 +1,25 @@
+module Webbynode::Commands
+  class Delete < Webbynode::Command
+    summary "Removes the current application from your Webby"
+    option :force, "Skips confirmation and forces the deletion of the app"
+    
+    add_alias "rm"
+    add_alias "remove"
+    
+    def execute
+      unless pushand.present?
+        io.log("Ahn!? Hello, McFly, anybody home?", true)
+        return
+      end
+      
+      app_name = pushand.parse_remote_app_name
+      if option(:force) or ask("Do you really want to delete application #{app_name} (y/n)? ").downcase == "y"
+        notify("Removing [#{app_name}] from your webby...")
+        remote_executor.exec "delete_app #{app_name} --force", true
+        notify("The application [#{app_name}] has been removed from your webby.\n\nThe webserver is restarting.")
+      else
+        puts "Aborted."
+      end
+    end
+  end
+end

data/lib/webbynode/commands/help.rb

@@ -0,0 +1,25 @@
+module Webbynode::Commands
+  class Help < Webbynode::Command
+    summary "Guess what? You're on it!"
+    parameter :command, "Command to get help on"
+    
+    def execute
+      if param(:command) == "commands"
+        puts "usage: webbynode COMMAND"
+        puts
+        puts "Available commands:"
+        dir = File.join(File.expand_path(File.dirname(__FILE__)), "/*.rb")
+        Dir[dir].each do |file|
+          command = file.split("/").last
+          command.gsub!(/\.rb/, "")
+          
+          puts "    #{command.ljust(10)} #{Webbynode::Command.class_for(command).setting(:summary)}"
+        end
+        puts 
+        puts "Try 'webbynode help COMMAND' for more information."
+      else
+        puts Help.for(param(:command)).help
+      end
+    end
+  end
+end

data/lib/webbynode/commands/init.rb

@@ -0,0 +1,77 @@
+module Webbynode::Commands
+  class Init < Webbynode::Command
+    summary "Prepares the application on current folder for deployment"
+    parameter :webby, String, "Name or IP of the Webby to deploy to"
+    parameter :dns, String, "The DNS used for this application", :required => false
+    option :adddns, "Creates the DNS entries for the domain"
+    option :engine, "Sets the application engine for the app", :validate => { :in => ['php', 'rack', 'rails', 'rails3'] }
+    
+    def execute
+      unless params.any?
+        io.log help
+        return
+      end
+      
+      webby     = param(:webby)
+      app_name  = io.app_name
+      
+      if param(:dns)
+        dns_entry = "#{param(:dns)}" 
+      else
+        dns_entry = app_name
+      end
+      
+      io.log "Initializing application #{app_name} #{dns_entry ? "with dns #{dns_entry}" : ""}", :start
+      
+      if webby =~ /\b(?:\d{1,3}\.){3}\d{1,3}\b/
+        webby_ip = webby
+      else
+        begin
+          io.log "Retrieving IP for Webby #{webby}...", :action
+          webby_ip = api.ip_for(webby)
+          unless webby_ip
+            if (webbies = api.webbies.keys) and webbies.any?
+              raise CommandError, 
+                "Couldn't find Webby '#{webby}' on your account. Your Webbies are: #{webbies.map { |w| "'#{w}'"}.to_phrase}."
+            else
+              raise CommandError, "You don't have any active Webbies on your account."
+            end
+          end
+        end
+      end
+      
+      io.log "Initializing directory structure...", :action
+      git.add_git_ignore unless io.file_exists?(".gitignore")
+
+      unless io.file_exists?(".pushand")
+        io.create_file(".pushand", "#! /bin/bash\nphd $0 #{app_name} #{dns_entry}\n", true)
+      end
+      
+      unless io.directory?(".webbynode")
+        io.exec("mkdir -p .webbynode/tasks") 
+        io.create_file(".webbynode/tasks/after_push", "")
+        io.create_file(".webbynode/tasks/before_push", "")
+        io.create_file(".webbynode/aliases", "")
+        io.create_file(".webbynode/config", "")
+      end
+
+      io.add_setting("engine", option(:engine)) if option(:engine)
+      
+      unless git.present?
+        io.log "Initializing git and applying initial commit...", :action
+        git.init 
+        git.add "." 
+        git.commit "Initial commit"
+      end
+      
+      io.log "Adding webbynode as git remote...", :action
+      git.add_remote "webbynode", webby_ip, app_name
+      
+      handle_dns param(:dns) if option(:adddns)
+      
+      io.log "Application #{app_name} ready for Rapid Deployment", :finish
+    rescue Webbynode::GitRemoteAlreadyExistsError
+      io.log "Application already initialized.", true
+    end
+  end
+end

data/lib/webbynode/commands/push.rb

@@ -0,0 +1,70 @@
+module Webbynode::Commands
+  class Push < Webbynode::Command
+    
+    requires_initialization!
+    
+    attr_accessor :app_name, :before_tasks, :after_tasks
+    
+    add_alias "deploy"
+    
+    summary "Sends pending changes on the current application to your Webby"
+    option :dirty, "Allows pushing even if the current application has git changes pending"
+    
+    def initialize(*args)
+      super
+      @before_tasks = Webbynode::Commands::Tasks.new
+      @after_tasks  = Webbynode::Commands::Tasks.new
+    end
+    
+    def execute
+      unless option(:dirty)
+        raise CommandError, 
+          "Cannot push because you have pending changes. Do a git commit or add changes to .gitignore." unless git.clean?
+      end
+      
+      @app_name = pushand.parse_remote_app_name
+      
+      # Ensures there are Task Files to read from
+      before_tasks.ensure_tasks_folder
+      
+      # Reads out the "before push" tasks file to see if there are any tasks that must be performed
+      # It will perform the "before push" tasks if there are any available
+      before_tasks.read_tasks(Webbynode::Commands::Tasks::BeforePushTasksFile)
+      perform_before_tasks if before_tasks.has_tasks?
+      
+      # Logs a initialization message to the user
+      # Pushes the application to Webbynode
+      io.log "Pushing #{app_name}", :start
+      io.exec("git push webbynode master", false)
+      
+      # Reads out the "after push" tasks file to see if there are any tasks that must be performed
+      # It will perform the "after push" tasks if there are any available
+      after_tasks.read_tasks(Webbynode::Commands::Tasks::AfterPushTasksFile)
+      perform_after_tasks if after_tasks.has_tasks?
+      
+      io.log "Finished pushing #{app_name}", :finish
+    end
+    
+    
+    private
+      
+      # Performs the before push tasks locally
+      def perform_before_tasks
+        io.log "Performing Before Push Tasks...", :action
+        before_tasks.session_tasks.each do |task|
+          io.log "  Performing Task: #{task}", :action
+          io.exec(task)
+        end
+      end
+      
+      # Performs the after push tasks remotely from the application root
+      def perform_after_tasks
+        io.log "Performing After Push Tasks...", :action
+        after_tasks.session_tasks.each do |task|
+          io.log "  Performing Task: #{task}", :action
+          remote_executor.exec("cd #{pushand.parse_remote_app_name}; #{task}", true)
+        end
+      end
+      
+  end
+end

data/lib/webbynode/commands/remote.rb

@@ -0,0 +1,28 @@
+module Webbynode::Commands
+  class NoOptionsProvided < StandardError; end
+  
+  class Remote < Webbynode::Command
+    summary "Execute commands on your Webby for the current application"
+    
+    requires_initialization!
+    requires_options!
+  
+    parameter :command, Array, "Commands to execute"
+  
+    def execute
+      unless server.application_pushed?
+        io.log "Before being able to run remote commands from your webby, you must first push your application to it."
+        exit
+      end
+      
+      # Parses Pushand File and returns remote application name
+      remote_app_name = pushand.parse_remote_app_name
+      
+      # Notify the user
+      io.log("Performing the requested remote command..", true)
+      
+      # Executes the command on the remote server inside the application root folder
+      remote_executor.exec("cd #{remote_app_name}; #{param_values.join(" ")}", true)
+    end
+  end
+end

data/lib/webbynode/commands/restart.rb

@@ -0,0 +1,25 @@
+module Webbynode::Commands
+  class Restart < Webbynode::Command
+    summary "Reboots your Webby"
+    add_alias "reboot"
+    
+    requires_initialization!
+        
+    def execute
+      exit if no?("Are you sure you wish to restart your webby? (y/n)")
+      
+      api.webbies.each do |webby|    
+        if webby[1][:ip].eql?(git.parse_remote_ip)
+          if webby[1][:status].eql?("on")
+            puts "#{webby[0]} will now be rebooted!"
+            api.post("/webby/#{webby[1][:name]}/reboot")
+          else
+            puts "#{webby[0]} is starting up!"
+            api.post("/webby/#{webby[1][:name]}/start")
+          end
+        end
+      end
+    end
+    
+  end
+end

data/lib/webbynode/commands/start.rb

@@ -0,0 +1,23 @@
+module Webbynode::Commands
+  class Start < Webbynode::Command
+    summary "Starts your Webby, when it's off"
+    add_alias "boot"
+    
+    requires_initialization!
+        
+    def execute
+      exit if no?("Are you sure you wish to start your webby? (y/n)")
+      
+      api.webbies.each do |webby|
+        if webby[1][:ip].eql?(git.parse_remote_ip)
+          unless webby[1][:status].eql?("on")
+            puts "#{webby[0]} is starting up!"
+            api.post("/webby/#{webby[1][:name]}/start")
+          else
+            puts "#{webby[0]} is already started up."
+          end
+        end
+      end
+    end
+  end
+end

data/lib/webbynode/commands/stop.rb

@@ -0,0 +1,23 @@
+module Webbynode::Commands
+  class Stop < Webbynode::Command
+    summary "Shuts down your Webby"
+    add_alias "shutdown"
+    
+    requires_initialization!
+        
+    def execute
+      exit if no?("Are you sure you wish to shutdown your webby? (y/n)")
+      
+      api.webbies.each do |webby|    
+        if webby[1][:ip].eql?(git.parse_remote_ip)
+          unless webby[1][:status].eql?("off")
+            puts "#{webby[0]} will now shutdown!"
+            api.post("/webby/#{webby[1][:name]}/shutdown")
+          else
+            puts "#{webby[0]} is already shutdown."
+          end
+        end
+      end
+    end
+  end
+end

data/lib/webbynode/commands/tasks.rb

@@ -0,0 +1,149 @@
+module Webbynode::Commands
+  class Tasks < Webbynode::Command
+    requires_initialization!
+    
+    attr_accessor :action, :type, :command, :session_file, :session_tasks
+
+    summary "Manages tasks executed before or after you push your changes"
+    parameter :action,  String, "add, remove or show.",       :required => true, :validate => { :in => ["add", "remove", "show"] }
+    parameter :type,    String, "before_push or after_push.", :required => true, :validate => { :in => ["before_push", "after_push"]}
+    parameter :command, Array, "Task to perform.",            :required => false
+    
+    # Constants
+    # Paths to the webbynode task files
+    TasksPath               = ".webbynode/tasks"
+    BeforePushTasksFile     = ".webbynode/tasks/before_push"
+    AfterPushTasksFile      = ".webbynode/tasks/after_push"
+    
+    def initialize(*args)
+      super
+      @session_tasks = Array.new
+    end
+    
+    def execute
+      
+      # Ensures that the tasks folder (.webbynode/tasks) is present
+      # Will create the task files if they are not present
+      ensure_tasks_folder
+
+      # Should parse the parameters
+      parse_parameters
+      
+      # Sets the current path, extracted from @type
+      set_session_file
+      
+      # Reads out the currently set tasks
+      read_tasks(session_file)
+      
+      # Initializes either [add], [remove] or [show] depending on user input
+      send(action)
+      
+    end
+    
+    # Checks to see if the session_tasks has any tasks
+    def has_tasks?
+      return true unless session_tasks.empty?
+      false
+    end
+    
+    # Reads the tasks straight from the specified file and stores them inside (in order)
+    # the session_tasks method.
+    def read_tasks(file)
+      @session_tasks = []
+      io.read_file(file).each_line do |line|
+        @session_tasks << line.gsub(/\n/,'') unless line.blank?
+      end
+    end
+    
+    # Ensures the presence of the .webbynode/tasks folder
+    # Will create the necessary task files when they are not available
+    def ensure_tasks_folder
+      io.exec('mkdir .webbynode/tasks') unless io.directory?(".webbynode/tasks")
+      %w[before_push after_push].each do |file|
+        io.exec("touch .webbynode/tasks/#{file}") unless io.file_exists?(".webbynode/tasks/#{file}")
+      end
+    end
+    
+    private
+      
+      # Gets invoked if the user specified [add] for @action
+      def add
+        append_task(command)
+        write_tasks
+        show_tasks
+      end
+
+      # Gets invoked if the user specified [remove] for @action    
+      def remove
+        delete_task(command.to_i)
+        write_tasks
+        show_tasks
+      end
+      
+      # Gets invoked if the user specified [show] for @action
+      def show
+        show_tasks  
+      end
+      
+      # Appends a task to the session_tasks method.
+      def append_task(task)
+        @session_tasks << task
+      end
+      
+      # Overwrites the existing file with the new tasks list
+      # This will always be done from the session_tasks.
+      def write_tasks
+        io.open_file(session_file, "w") do |file|
+          session_tasks.each do |task|
+            file.write "#{task}\n"
+          end
+        end
+      end
+      
+      # Removes a task based on the number(index) provided.
+      # example: delete_task(2)
+      # This will remove whatever task is 3rd in the session_tasks array.
+      def delete_task(i)
+        filtered_tasks = []
+        session_tasks.each_with_index do |task, index|
+          filtered_tasks << task unless index.eql?(i)
+        end
+        @session_tasks = filtered_tasks
+      end
+      
+      # Reads out each task (in order) either from the session_tasks method
+      # or straight from the physical file on the filesystem and outputs it directly
+      # in the console to the user for feedback.
+      def show_tasks(from_file = false)
+        read_tasks(session_file, true) if from_file
+        if session_tasks.empty?
+          io.log_and_exit "You haven't set up any tasks for \"#{type.gsub('_',' ').capitalize}\"."
+        end
+        io.log "These are the current tasks for \"#{type.gsub('_',' ').capitalize}\":"
+        session_tasks.each_with_index do |task, index|
+          io.log "[#{index}] #{task}"
+        end
+      end
+      
+      # Determines the selected file that will be used for the current session.
+      # This will be stored inside the session_file method.
+      def set_session_file
+        case @type
+        when 'before_push'    then sf = BeforePushTasksFile
+        when 'after_push'     then sf = AfterPushTasksFile
+        end
+        @session_file = sf
+      end
+      
+      # Parses the parameters and stores the params inside 3 different methods
+      # [action]  represents: [add/remove/show]
+      # [type]    represents: [before/after_create before/after_push]
+      # [command] represents: The remote command that should get executed
+      def parse_parameters
+        @action   = param(:action)
+        @type     = param(:type)
+        @command  = param(:command).join(" ")
+      end
+        
+  end
+end

data/lib/webbynode/commands/version.rb

@@ -0,0 +1,8 @@
+module Webbynode::Commands
+  class Version < Webbynode::Command
+    summary "Displays current version of Webbynode Gem"
+    def execute
+      io.log("Rapid Deployment Gem v#{Webbynode::VERSION}", true)
+    end
+  end
+end

data/lib/webbynode/commands/webbies.rb

@@ -0,0 +1,30 @@
+module Webbynode::Commands
+  class Webbies < Webbynode::Command
+    summary "Lists the Webbies you currently own"
+    
+    def execute
+      puts "Fetching list of your Webbies..."
+      puts ""
+      
+      header =  "  "
+      header << "Webbies".ljust(16)
+      header << "IP".ljust(16)
+      header << "Node".ljust(10)
+      header << "Plan".ljust(16)
+      header << "Status".ljust(15)
+      
+      puts header
+      
+      api.webbies.each_pair do |name, webby|
+        str = "  "
+        str << name.ljust(16)
+        str << webby[:ip].ljust(16)
+        str << webby[:node].ljust(10)
+        str << webby[:plan].ljust(16)
+        str << webby[:status]
+        
+        puts str
+      end
+    end
+  end
+end

data/lib/webbynode/git.rb

@@ -0,0 +1,112 @@
+module Webbynode
+  class GitError < StandardError; end
+  class GitNotRepoError < StandardError; end
+  class GitRemoteDoesNotExistError < StandardError; end
+  class GitRemoteAlreadyExistsError < StandardError; end
+
+  class Git
+    attr_accessor :config, :remote_ip
+    
+    def present?
+      io.directory?(".git")
+    end
+    
+    def io
+      @@io ||= Webbynode::Io.new
+    end
+    
+    def init
+      exec("git init") do |output|
+        # this indicates init was properly executed
+        output =~ /^Initialized empty Git repository in/
+      end
+    end
+    
+    def clean?
+      io.exec("git status") =~ /working directory clean/
+    end
+    
+    def delete_file(file)
+      return unless io.file_exists?(file)
+      io.delete_file(file)
+      exec "git rm #{file} > /dev/null 2>&1"
+    end
+    
+    def add_git_ignore
+      io.create_from_template(".gitignore", "gitignore")
+    end
+    
+    def add(what)
+      exec "git add #{what}"
+    end
+    
+    def add_remote(name, host, repo)
+      exec("git remote add #{name} git@#{host}:#{repo}") do |output|
+        # raise an exception if remote already exists
+        raise GitRemoteAlreadyExistsError, output if output =~ /remote \w+ already exists/
+        
+        # success if output is empty
+        output.nil? or output.empty?
+      end
+    end
+    
+    def commit(comments)
+      comments.gsub! /"/, '\"'
+      exec("git commit -m \"#{comments}\"") do |output|
+        output =~ /#{comments}/ or output =~ /nothing to commit/
+      end
+    end
+
+    def parse_config
+      return @config if defined?(@config)
+      if present? and remote_webbynode?
+        config = {}
+        current = {}
+        File.open(".git/config").each_line do |line|
+          case line
+          when /^\[(\w+)(?: "(.+)")*\]/
+            key, subkey = $1, $2
+            current = (config[key] ||= {})
+            current = (current[subkey] ||= {}) if subkey
+          else
+            key, value = line.strip.split(' = ')
+            current[key] = value
+          end
+        end
+        @config = config
+      else
+        raise Webbynode::GitNotRepoError, "Git repository does not exist." unless present?
+        raise Webbynode::GitRemoteDoesNotExistError, "Webbynode has not been initialized." unless remote_webbynode?
+      end
+    end
+    
+    def parse_remote_ip
+      @config     ||= parse_config
+      @remote_ip  ||= ($2 if @config["remote"]["webbynode"]["url"] =~ /^(\w+)@(.+):(.+)$/) if @config
+    end
+    
+    def remote_webbynode?
+      return true if io.exec('git remote') =~ /webbynode/
+      false 
+    end
+    
+    private
+    
+      def exec(cmd, &blk)
+        handle_output io.exec(cmd), &blk
+      end
+    
+      def handle_output(output, &blk)
+        raise GitNotRepoError, output if output =~ /Not a git repository/
+
+        if blk
+          raise GitError, output unless blk.call(output)
+        else
+          raise GitError, output unless output.nil? or output.empty?
+        end
+      
+        true
+      end
+    
+  end
+end