webbynode 0.1.2 → 0.2.0

data/lib/webbynode/api_client.rb

@@ -0,0 +1,121 @@
+require 'httparty'
+
+module Webbynode
+  class ApiClient
+    include HTTParty
+    base_uri "https://manager.webbynode.com/api/yaml"
+
+    CREDENTIALS_FILE = "#{ENV['HOME']}/.webbynode"
+
+    Unauthorized = Class.new(StandardError)
+    InactiveZone = Class.new(StandardError)
+    ApiError = Class.new(StandardError)
+    
+    def io
+      @io ||= Io.new
+    end
+    
+    def zones
+      response = post("/dns")
+      if zones = response["zones"]
+        zones.inject({}) { |h, zone| h[zone[:domain]] = zone; h }
+      end
+    end
+    
+    def create_record(record, ip)
+      original_record = record
+
+      url = Domainatrix.parse("http://#{record}")
+      record = url.subdomain
+      domain = "#{url.domain}.#{url.public_suffix}."
+      
+      zone = zones[domain]
+      if zone
+        raise InactiveZone, domain unless zone[:status] == 'Active'
+      else
+        zone = create_zone(domain)
+      end
+
+      create_a_record(zone[:id], record, ip, original_record)
+    end
+    
+    def create_zone(zone)
+      response = post("/dns/new", :query => {"zone[domain]" => zone, "zone[ttl]" => "86400"})
+      handle_error(response)
+      response
+    end
+    
+    def create_a_record(id, record, ip, original_record)
+      response = post("/dns/#{id}/records/new", :query => {"record[name]" => record, "record[type]" => "A", "record[data]" => ip})
+      if response["errors"] and response["errors"] =~ /Data has already been taken/
+        io.log "'#{original_record}' is already setup on Webbynode DNS, make sure it's pointing to #{ip}", :warning
+        return
+      end
+      
+      handle_error(response)
+      response["record"]
+    end
+    
+    def handle_error(response)
+      raise ApiError, response["error"] if response["error"]
+      raise ApiError, "invalid response from the API (code #{response.code})" unless response.code == 200
+    end
+    
+    def ip_for(hostname)
+      (webbies[hostname] || {})[:ip]
+    end
+    
+    def webbies
+      unless @webbies
+        response = post("/webbies") || {}
+        
+        @webbies = response
+      end
+      
+      @webbies['webbies'].inject({}) { |h, webby| h[webby[:name]] = webby; h }
+    end
+    
+    def credentials
+      @credentials ||= init_credentials
+    end
+    
+    def init_credentials(overwrite=false)
+      creds = if io.file_exists?(CREDENTIALS_FILE) and !overwrite
+        properties
+      else
+        email = overwrite[:email] if overwrite.is_a?(Hash) and overwrite[:email]
+        token = overwrite[:token] if overwrite.is_a?(Hash) and overwrite[:token]
+        
+        puts io.read_from_template("api_token") unless email and token
+
+        email ||= ask("Login email: ")
+        token ||= ask("API token:   ")
+        
+        response = self.class.post("/webbies", :body => { :email => email, :token => token })
+        if response.code == 401 or response.code == 411
+          raise Unauthorized, "You have provided the wrong credentials"
+        end
+
+        properties['email'] = email
+        properties['token'] = token
+        properties.save
+        
+        puts
+
+        { :email => email, :token => token }
+      end
+    end
+    
+    def properties
+      @properties ||= Webbynode::Properties.new(CREDENTIALS_FILE)
+    end
+    
+    def post(uri, options={})
+      response = self.class.post(uri, { :body => credentials }.merge(options))
+      if response.code == 401 or response.code == 411
+        raise Unauthorized, "You have provided the wrong credentials"
+      end
+      response
+    end
+  end
+end

data/lib/webbynode/application.rb

@@ -0,0 +1,21 @@
+module Webbynode
+  class AppError < StandardError; end
+
+  class Application
+    attr_reader :command, :params, :aliases
+    
+    def initialize(*args)
+      args = ["help", "commands"] unless args.any?
+      
+      @command = args.shift
+      @params = args
+    end
+    
+    def execute
+      if command_class = Webbynode::Command.for(command)
+        cmd = command_class.new(*params)
+        cmd.run
+      end
+    end
+  end
+end

data/lib/webbynode/command.rb

@@ -0,0 +1,332 @@
+require 'jcode'
+
+module Webbynode
+  class Command
+    Aliases = {}
+    Settings = {}
+    
+    InvalidOption = Class.new(StandardError)
+    InvalidCommand = Class.new(StandardError)
+    CommandError = Class.new(StandardError)
+    
+    def Command.inherited(child)
+      Settings[child] ||= { 
+        :parameters_hash => {}, 
+        :options_hash => {}, 
+        :parameters => [], 
+        :options => [] 
+      }
+    end
+    
+    class << self
+      # classes that requires checking
+      # for webbynode init must call
+      # this method
+      def requires_initialization!
+        Settings[self][:requires_initialization!] = true
+      end
+      
+      def requires_options!
+        Settings[self][:requires_options!] = true
+      end
+      
+      def requires_pushed_application!
+        Settings[self][:requires_pushed_application!] = true
+      end
+      
+      def description(s)
+        Settings[self][:description] = s
+      end
+      
+      def summary(s)
+        Settings[self][:summary] = s
+      end
+      
+      def setting(s)
+        Settings[self][s]
+      end
+      
+      def parameter(*args)
+        param = Parameter.new(*args)
+        Settings[self][:parameters] << param
+        Settings[self][:parameters_hash][param.name] = param
+      end
+      
+      def option(*args)
+        option = Option.new(*args)
+        Settings[self][:options] << option
+        Settings[self][:options_hash][option.name] = option
+      end
+      
+      def class_for(command)
+        Webbynode::Commands.const_get command_class_name(command)
+      end
+      
+      def for(command)
+        begin
+          class_for(command)
+        rescue NameError
+          
+          # Assumes Command Not Found
+          # Will attempt to find/read possible aliases that might
+          # have been set up by the user
+          if File.directory?('.webbynode')
+            a = Webbynode::Commands::Alias.new 
+            a.read_aliases_file
+            if a.exists?(command)
+              remote_command = a.extract_command(command)
+              r = Webbynode::Commands::Remote.new(remote_command)
+              r.execute
+              return
+            end
+          end  
+          
+          # If no aliases:
+          puts "Command \"#{command}\" doesn't exist"
+        end
+      end
+      
+      def add_alias(alias_name)
+        Aliases[alias_name] = self.name.split("::").last
+      end
+
+      def command_class_name(command)
+        return Aliases[command] if Aliases[command]
+        class_name = command.split("_").inject([]) { |arr, item| arr << item.capitalize }.join("")
+      end
+    end
+
+    def initialize(*args)
+      parse_args(args)
+    rescue InvalidCommand, CommandError
+      @parse_error = $!.message
+    end
+
+    def self.command
+      str = ""
+      self.name.split("::").last.each_char do |ch| 
+        str << "_" if ch.match(/[A-Z]/) and !str.empty?
+        str << ch.downcase
+      end
+      str
+    end
+    
+    def param(p)
+      params_hash[p].value if params_hash[p]
+    end
+    
+    def option(p)
+      raise CommandError, "Unknown option: #{p}." unless options[p]
+      options[p].value if options[p]
+    end
+    
+    def params_hash
+      settings[:parameters_hash]
+    end
+    
+    def options
+      settings[:options_hash]
+    end
+    
+    def params
+      settings[:parameters]
+    end
+
+    def param_values
+      settings[:parameters].map { |p| p.value }
+    end
+    
+    def self.summary_help
+      Settings[self][:summary]
+    end
+    
+    def self.usage
+      help = "Usage: webbynode #{command}"
+      if (params = Settings[self][:parameters])
+        params.each do |p|
+          help << " #{p.to_s}"
+        end
+      end
+      
+      help << " [options]" if (Settings[self][:options] || []).any?
+      help
+    end
+    
+    def self.params_help
+      help = []
+      if (params = Settings[self][:parameters])
+        help << "Parameters:"
+        params.each do |p|
+          help << "    #{p.name.to_s.ljust(20)}#{p.desc}#{p.required? ? "" : ", optional"}"
+        end
+      end
+      help.join("\n")
+    end
+    
+    def self.options_help
+      help = []
+      if (options = Settings[self][:options] || []).any?
+        help << "Options:"
+        options.each do |p|
+          help << "    #{p.to_s.ljust(20)}#{p.desc}#{p.required? ? "" : ", optional"}"
+        end
+      end
+      help.join("\n")
+    end
+    
+    def self.help
+      help = []
+      help << summary_help if summary_help
+      help << usage
+      help << params_help if Settings[self][:parameters].any?
+      help << options_help if (Settings[self][:options] || []).any?
+      
+      help.join("\n")
+    end
+    
+    def io
+      @@io ||= Webbynode::Io.new
+    end
+    
+    def git
+      @@git ||= Webbynode::Git.new
+    end
+    
+    def server
+      @server ||= Webbynode::Server.new(git.parse_remote_ip)
+    end
+    
+    def remote_executor
+      @remote_executor ||= Webbynode::RemoteExecutor.new(git.parse_remote_ip)
+    end
+    
+    def pushand
+      @pushand ||= PushAnd.new
+    end
+    
+    def api
+      @@api ||= Webbynode::ApiClient.new
+    end
+    
+    def notify(msg)
+      Webbynode::Notify.message(msg)
+    end
+
+    def yes?(question)
+      answer = ask(question).downcase
+      return true   if %w[y yes].include?(answer)
+      return false  if %w[n no].include?(answer)
+      exit
+    end
+    
+    def no?(question)
+      answer = ask(question).downcase
+      return true   if %w[n no].include?(answer)
+      return false  if %w[y yes].include?(answer)
+      exit
+    end
+    
+    def validate_initialization
+      raise CommandError,
+        "Ahn!? Hello, McFly, anybody home?" unless git.present?
+      raise CommandError,
+        "Webbynode has not been initialized for this git repository." unless git.remote_webbynode?
+      raise CommandError,
+        "Could not find .webbynode folder, has Webbynode been initialized for this repository?" unless io.directory?('.webbynode')
+      raise CommandError,
+        "Could not find .pushand file, has Webbynode been initialized for this repository?" unless pushand.present?
+    end
+    
+    def validate_options
+      raise Webbynode::Commands::NoOptionsProvided,
+        "No remote options were provided." if params.empty?
+    end
+    
+    def settings
+      Settings[self.class] || {}
+    end
+    
+    def run
+      if @parse_error
+        puts "#{@parse_error} Use \"webbynode help #{self.class.command}\" for more information."
+        puts self.class.usage
+        return
+      end
+      
+      if @help
+        puts self.class.help
+        return
+      end
+      
+      begin
+        validate_initialization                   if settings[:requires_initialization!]
+        validate_options                          if settings[:requires_options!]
+        execute
+      rescue Webbynode::ApiClient::Unauthorized
+        puts "Your credentials didn't match any Webbynode account."
+      rescue CommandError
+        # io.log $!
+        puts $!
+      end
+    end
+    
+    private
+
+    def parse_args(args)
+      settings[:options].each { |o| o.reset! }
+      settings[:parameters].each { |p| p.reset! }
+
+      i = 0
+      while (opt = args.shift)
+        if opt == "--help"
+          @help = true
+          return
+        elsif (name = Option.name_for(opt))
+          option = settings[:options_hash][name.to_sym]
+          raise Webbynode::Command::CommandError, "Unknown option: #{name.to_sym}." unless option
+          option.parse(opt)
+        else
+          raise InvalidCommand, "command '#{self.class.command}' takes no parameters" if settings[:parameters].empty?
+          
+          if settings[:parameters][i].array?
+            settings[:parameters][i].value << opt
+          else
+            settings[:parameters][i].value = opt
+            i += 1
+          end
+        end
+      end
+      
+      # If help is invoked without any arguments, the first argument will
+      # be set to "commands" so it will always display a list of available commands.
+      if self.class.command.eql?("help") and param(:command).blank?
+        settings[:parameters][0].value = "commands"
+      end
+
+      settings[:parameters].each { |p| p.validate! }
+    end
+    
+    def handle_dns(dns)
+      url = Domainatrix.parse("http://#{dns}")
+      ip = git.parse_remote_ip
+      
+      if url.subdomain.empty?
+        dns = "#{url.domain}.#{url.public_suffix}"
+        io.log "Creating DNS entries for www.#{dns} and #{dns}..."
+        io.add_setting "dns_alias", "'www.#{dns}'"
+        api.create_record "#{dns}", ip
+        api.create_record "www.#{dns}", ip
+      else
+        io.log "Creating DNS entry for #{dns}..."
+        io.remove_setting "dns_alias"
+        api.create_record dns, ip
+      end
+    rescue Webbynode::ApiClient::ApiError
+      if $!.message =~ /Data has already been taken/
+        io.log "The DNS entry for '#{dns}' already existed, ignoring."
+      else
+        io.log "Couldn't create your DNS entry: #{$!.message}"
+      end
+    end
+  end
+end

data/lib/webbynode/commands/add_backup.rb

@@ -0,0 +1,33 @@
+module Webbynode::Commands
+  class AddBackup < Webbynode::Command
+    summary "Configures automatic nightly backups for the current application"
+    option :retain, "Number of backups to retain on S3 (one backup per day), default is 30", :take => :days
+    
+    def execute
+      key    = io.general_settings['aws_key']   
+      secret = io.general_settings['aws_secret']
+      
+      unless key and secret
+        puts io.read_from_template("backup")
+        
+        key    = ask("AWS key: ")
+        secret = ask("AWS secret: ") unless key.blank?
+        
+        if key.blank? or secret.blank?
+          puts 
+          puts "Aborted."
+          return
+        end
+        
+        io.add_general_setting("aws_key", key)
+        io.add_general_setting("aws_secret", secret)
+      end
+
+      app_name = io.app_name
+      io.log "Configuring backup for #{app_name}...", :start
+      
+      retain = option(:retain)
+      remote_executor.exec %Q(config_app_backup #{app_name} "#{key}" "#{secret}"#{retain.blank? ? "" : " #{retain}"}), true
+    end
+  end
+end

data/lib/webbynode/commands/add_key.rb

@@ -0,0 +1,24 @@
+module Webbynode::Commands
+  class AddKey < Webbynode::Command
+    requires_initialization!
+
+    summary "Adds your ssh public key to your Webby, making deployments easy"
+    option :passphrase, "If present, passphrase will be used when creating a new SSH key", :take => :words
+
+    LocalSshKey = "#{ENV['HOME']}/.ssh/id_rsa.pub"
+    
+    add_alias "addkey"
+    
+    def execute
+      server.add_ssh_key LocalSshKey, options[:passphrase].value
+      io.log "Your local SSH Key has been added to your webby!", :notify
+
+    rescue Webbynode::InvalidAuthentication
+      io.log "Could not connect to webby: invalid authentication.", true
+
+    rescue Webbynode::PermissionError
+      io.log "Could not create an SSH key: permission error.", true
+      
+    end
+  end
+end

data/lib/webbynode/commands/alias.rb

@@ -0,0 +1,153 @@
+module Webbynode::Commands
+  class Alias < Webbynode::Command
+  
+    attr_accessor :action, :alias, :command, :session_aliases
+    
+    add_alias "aliases"
+    
+    requires_initialization!
+
+    summary "Manages a list of alias for your common used remote commands"
+    parameter :action,  String, "add, remove or show",    
+      :required => true,
+      :validate => { :in => ['add', 'remove', 'show' ]}
+    parameter :alias,   String, "name of the alias",      :required => false
+    parameter :command, Array,  "command to be executed", :required => false
+    
+    FilePath = ".webbynode/aliases"
+    
+    def initialize(*args)
+      super
+      @session_aliases = Array.new
+
+      # Ensures that the aliases file exists inside the .webbynode/ folder
+      ensure_aliases_file_exists
+    end
+    
+    def execute
+      
+      # Reads out the aliases from the aliases file and stores them in session_aliases
+      read_aliases_file
+      
+      # Parses the parameters that were provided by the user
+      parse_parameters
+      
+      # Initializes the specified action
+      send(action)
+      
+    end
+
+    # Reads out the aliases file and stores all the aliases inside the session_aliases array
+    def read_aliases_file
+      @session_aliases = Array.new
+      io.read_file(FilePath).each_line do |line|
+        if line =~ /\[(.+)\] (.+)/
+          @session_aliases << "[#{$1}] #{$2}"
+        end
+      end
+    end
+    
+    # Determines whether an alias already exists inside the session_aliases array
+    def exists?(a)
+      session_aliases.each do |session_alias|
+        if session_alias =~ /\[(.+)\]/
+          return true if $1.eql?(a)
+        end
+      end
+      false
+    end
+
+    # Ensures that the aliases file exists
+    # If the file does not exist, it will be created
+    def ensure_aliases_file_exists
+      unless io.file_exists?(FilePath)
+        io.exec("touch #{FilePath}")
+      end
+    end
+    
+    def extract_command(a)
+      session_aliases.each do |session_alias|
+        if session_alias =~ /\[(.+)\] (.+)/
+          return $2 if a.eql?($1)
+        end
+      end
+      false
+    end
+    
+    private
+      
+      # Parses the paramters provided by the user
+      def parse_parameters
+        @action  = param(:action)
+        @alias   = param(:alias)
+        @command = param(:command).join(" ")
+      end
+      
+      # Adds/Writes a new alias to the aliases file
+      def add
+        append_alias
+        write_aliases
+        show_aliases
+      end
+      
+      # Removes an alias from the aliases file
+      def remove
+        remove_alias
+        write_aliases
+        show_aliases
+      end
+      
+      # Displays the list of currently inserted aliases
+      def show
+        show_aliases
+      end
+      
+      # Writes all aliases from the session_aliases array to the file
+      # It will completely overwrite the existing file
+      def write_aliases
+        io.open_file(FilePath, "w") do |file|
+          session_aliases.each do |a|
+            file << a + "\n"
+          end
+        end
+      end
+      
+      # Appends an alias to the session_aliases unless..
+      # - There is no command provided for the alias
+      # - There is already an alias that exists with the same name
+      def append_alias
+        if !command.blank? and !exists?(@alias)
+          notify("Alias added:\n[#{@alias}] #{command}")
+          @session_aliases << "[#{@alias}] #{command}"
+        else
+          io.log("You must provide a remote command for the alias.", true) if command.blank?
+          io.log("You already have an alias named [#{@alias}].", true) if exists?(@alias)
+        end
+      end
+      
+      # Removes the specified alias from the session_aliases if it exists
+      def remove_alias
+        tmp_aliases = @session_aliases
+        @session_aliases = Array.new
+        tmp_aliases.each do |a|
+          if a =~ /\[(.+)\] .+/
+            @session_aliases << a unless $1.eql?(@alias)
+            notify("Alias removed: [#{@alias}]") if $1.eql?(@alias)
+          end
+        end
+      end
+      
+      # Outputs every alias from the session_aliases to the user
+      def show_aliases
+        if session_aliases.any?
+          io.log "These are your current aliases.."
+          session_aliases.each do |a|
+            io.log a
+          end
+        else
+          io.log "You have not yet set up any aliases.", true
+        end
+      end
+      
+  end
+end