ftl 0.2.3 → 0.2.4

data/.gitignore

@@ -4,3 +4,5 @@ vendor/bundle
 results.html
 pkg
 html
+
+.rvmrc

data/Changelog

@@ -1,18 +1,26 @@
-Release Version 0.2.2 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+# Release Version 0.2.4 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+* Add ftl <action> <server> to execute arbitrary commands on running instances
+* Add ftl sample_config to see the latest sample ftl.yml
+* Add ftl images # Shows AMIs associated with your account
+
+# Release Version 0.2.3 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
   
-  * Add ftl status
-  * find_instances returns exact match preferentially
+* Add ftl status
+* find_instances returns exact match preferentially
+* Update README with more examples and setup
+* Adds :keys config parameter
 
-Release Version 0.2.2 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+# Release Version 0.2.2 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-  * Adds templates feature to config file
-  * Start and cancel spot requests
-  * Execution without parameters shows help screen
-  * Fixes various bugs
+* Adds templates feature to config file
+* Start and cancel spot requests
+* Execution without parameters shows help screen
+* Fixes various bugs
 
-Release Version 0.2.0 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+# Release Version 0.2.0 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
- * First revamped release handling AWS in a more generic way
+* First revamped release handling AWS in a more generic way
 
 Previous releases were focused on starting up Pair Programming servers. 
 The latest releases can also be used for this but are more useful in a generic 

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    ftl (0.2.3)
+    ftl (0.2.4)
       fog
       formatador (~> 0.2.2)
 

data/README.md

@@ -4,7 +4,7 @@ Faster Than Light. Fog Terminal Language. For Terminal Launching.
 
 ## Description
 
-Ftl is an AWS (fog-based) application for managing cloud instances from the command line.
+`ftl` is an AWS (fog-based) application for managing cloud instances from the command line.
 Easier than chef or the ec2 command line tools. Smarter too.
 
 ## Installation
@@ -15,8 +15,6 @@ Install is easy.
 
 ## Usage
 
-### Example commands
-
     Usage: ftl [<config-options>] <command> [<command-options>]
       commands: start, kill, list, edit, connect, servers, tags, images, snapshots, volumes
       examples:
@@ -35,10 +33,75 @@ Install is easy.
         ftl headers servers                # Show possible headers for servers
         ftl headers volumes                # Show possible headers for volumes
         ftl edit                           # Edit ftl.yml with your $EDITOR
-        ftl --config=~/ftl.yml servers     # Uses custom config file 
-        ftl --headers=id,tags.Name servers # Uses specified headers 
+        ftl --config=~/ftl.yml servers     # Uses custom config file
+        ftl --headers=id,tags.Name servers # Uses specified headers
         ftl --version                      # Show version number
 
+## Getting started
+
+`ftl` depends on a configuration file. When you run it for the first time,
+it will create a simple configuration file at `~/.ftl/ftl.yml`. Note that the starter file is incomplete;
+you will need to supply at least your Amazon AWS security credentials. You can open the
+configuration file in the editor named by the `$EDITOR` environment variable by running `ftl edit`.
+
+### Configuration file
+
+In addition to the AWS security credentials, the configuration file contains parameters for
+launching instances and connecting to them.
+
+    ACCESS_KEY_ID:      # Amazon AWS access key
+    SECRET_ACCESS_KEY:  # Amazon AWS secret access key
+
+    :keys:
+      ninja-keypair:        ~/.ec2/id_rsa-ninja-keypair
+
+    :templates:
+      :ninja:
+        :ami:               ami-a29943cb  # Ubuntu 12.04 LTS Precise Pangolin
+        :username:          ubuntu
+        :keypair:           ninja-keypair
+        :instance_type:     m1.small
+        :tags:              {}
+        :groups:
+          - default
+          - apache
+          - postgresql
+
+#### The :templates section
+
+`:templates` is a hash of server names and the EC2 parameters used to launch them.
+
+* :ami -- the ID of the AMI to use
+* :availability_zone -- the availability zone into which the instance should be launched
+* :groups -- a list of names and/or IDs of security groups to assign to the instance
+* :instance_type -- the name of the EC2 instance size (e.g. 'm1.small')
+* :ip_private -- the private IP address to assign to the instance (optional)
+* :ip_public -- the public IP address to assign to the instance (optional)
+* :keypair -- the name of the keypair installed in the instance when launched; this is important
+              for connecting to the instance once it has been launched
+* :subnet_id -- the ID of the subnet into which the instance should be launched (optional)
+* :tags -- a hash of tags to be set on the instance; 'Name' will be automatically set from the
+           server name
+* :username -- the username to use when connecting to the instance
+
+#### A note on security groups
+
+Security groups defined in a virtual private cloud (VPC) can be specified only by ID.
+
+#### The :keys section
+
+`:keys`, if defined, is a hash of keypair names and the names of files on the local filesystem
+containing them. If there is an entry in `:keys` with the same name as the server, the file will be
+passed in the `-i` option to `ssh` when connecting.
+
+### Launching an instance
+
+Once a server has been configured, it can be launched by name.
+
+    ftl launch ninja
+
+To connect to it, run `ftl connect ninja`.
+
 ## Contributing
 
 1. Fork it

data/bin/ftl

@@ -11,6 +11,10 @@ optparse = OptionParser.new do |opts|
     exit
   end
 
+  # opts.on('-s', '--sample-config', "Displays sample ftl.yml config file") do |opts|
+  #   Ftl.sample_config
+  # end
+
   opts.on('-d', '--headers FILE', Array, "provide custom headers") do |headers|
     options[:headers] = headers
   end

data/lib/ftl/client.rb

@@ -20,8 +20,10 @@ module Ftl
         ftl headers servers                # Show possible headers for servers
         ftl headers volumes                # Show possible headers for volumes
         ftl edit                           # Edit ftl.yml with your $EDITOR
-        ftl --config=~/ftl.yml servers     # Uses custom config file 
-        ftl --headers=id,tags.Name servers # Uses specified headers 
+        ftl images                         # Show AMIs associated with your account
+        ftl <action> ninja                 # Execute the <action> (specified in ftl.yml) on the remote server instance
+        ftl --config=~/ftl.yml servers     # Uses custom config file
+        ftl --headers=id,tags.Name servers # Uses specified headers
         ftl --version                      # Show version number
     }
   end
@@ -32,39 +34,59 @@ module Ftl
 
   class Client
 
+    SINGLE_COMMANDS = %w{ edit sample }
+
     attr_reader :con
     attr_accessor :options
 
     def initialize(args=nil, opts={})
       load_config(opts)
-      @con = Fog::Compute.new(:provider => 'AWS', :aws_secret_access_key => options['SECRET_ACCESS_KEY'], :aws_access_key_id => options['ACCESS_KEY_ID'])
       if args && args.length > 0
         arg = args.reverse.pop
-        send(arg, args - [arg])
+        if (!SINGLE_COMMANDS.include?(arg))
+          @con = Fog::Compute.new(:provider => 'AWS', :aws_secret_access_key => options['SECRET_ACCESS_KEY'], :aws_access_key_id => options['ACCESS_KEY_ID'])
+        end
+        begin
+          send(arg, args - [arg])
+        rescue
+          Ftl.help
+        end
       else
         Ftl.help
       end
     end
 
-    def launch(args={})
-      if args.first.nil?
-        display "Please provide a short name for instance\n\t[bold]ftl[/] launch <name>"
-        return
-      end
+    def launch_instance(args)
       display "Spinning up FTL..."
       opts = options
       opts = options[:templates][args.first.to_sym] if !options[:templates][args.first.to_sym].nil?
-      server = con.servers.create(:user_data         => opts[:user_data],
-                                  :key_name          => opts[:keypair], 
-                                  :groups            => opts[:groups], 
-                                  :image_id          => opts[:ami], 
-                                  :availability_zone => opts[:availability_zone], 
-                                  :flavor_id         => opts[:instance_type], 
-                                  :username          => opts[:username],
-                                  :tags              => opts[:tags].merge(:Name => args.first)
-                                  )
+
+      opts[:group_ids] = (opts[:group_ids] || []) + opts[:groups].select { | group | group.to_s =~ /^sg-[0-9a-f]{8}$/ }
+      opts[:groups] = opts[:groups].reject { | group | group.to_s =~ /^sg-[0-9a-f]{8}$/ }
+
+      server = con.servers.create(:user_data          => opts[:user_data],
+                                  :key_name           => opts[:keypair],
+                                  :groups             => opts[:groups],
+                                  :security_group_ids => opts[:group_ids],
+                                  :image_id           => opts[:ami],
+                                  :availability_zone  => opts[:availability_zone],
+                                  :flavor_id          => opts[:instance_type],
+                                  :username           => opts[:username],
+                                  :tags               => opts[:tags].merge(:Name => args.first),
+                                  :subnet_id          => opts[:subnet_id],
+                                  :private_ip_address => opts[:ip_private],
+                                 )
+
       display server
-      eval(options[:post_script]) if options[:post_script]
+      display "Executing :post_script..." if opts[:post_script]
+      eval(opts[:post_script]) if opts[:post_script]
+    end
+
+    def launch(args={})
+      guard(args.first, "Please provide a short name for instance\n\t[bold]ftl[/] launch <name>")
+      display "Spinning up FTL..."
+      options.merge(options[:templates][args.first.to_sym]) if !options[:templates][args.first.to_sym].nil?
+      server = launch_instance(args)
     end
     alias :up     :launch
     alias :spinup :launch
@@ -72,28 +94,12 @@ module Ftl
     alias :new    :launch
 
     def spot(args={})
-      if args.first.nil?
-        display "Please provide a short name for instance\n\t[bold]ftl[/] spot <name> <price>"
-        return
-      end
-      if args[1].nil?
-        display "Please provide a price for spot request\n\t[bold]ftl[/] spot <name> <price>"
-        return
-      end
+      guard(args.first, "Please provide a short name for instance\n\t[bold]ftl[/] spot <name> <price>")
+      guard(args[1], "Please provide a price for spot request\n\t[bold]ftl[/] spot <name> <price>")
       display "Spinning up FTL..."
-      opts = options
-      opts = options[:templates][args.first.to_sym] if !options[:templates][args.first.to_sym].nil?
-      server = con.spot_requests.create(:user_data         => opts[:user_data],
-                                        :price             => args[1],
-                                        :key_name          => opts[:keypair], 
-                                        :groups            => opts[:groups], 
-                                        :image_id          => opts[:ami], 
-                                        :availability_zone => opts[:availability_zone], 
-                                        :flavor_id         => opts[:instance_type], 
-                                        :username          => opts[:username],
-                                        :tags              => {:Name => args.first}
-                                        )
-      display server
+      options.merge(options[:templates][args.first.to_sym]) if !options[:templates][args.first.to_sym].nil?
+      options[:price] = args[1]
+      server = launch_instance(args)
     end
 
     def spots(args={})
@@ -101,10 +107,7 @@ module Ftl
     end
 
     def cancel(args={})
-      if args.first.nil?
-        display "Please provide the id for the spot request to cancel."
-        return
-      end
+      guard(args.first, "Please provide the id for the spot request to cancel.") 
       spot = con.spot_requests.get(args.first)
       if spot && spot.destroy
         display "Canceled Spot Instance #{spot.id}."
@@ -115,7 +118,9 @@ module Ftl
 
     def connect(args={})
       if match = find_instances(args.first).select{|i| i.state == "running" }.first
-        exec("ssh #{options[:username]||'root'}@#{match[:dns_name]}")
+        opt_key = "-i #{options[:keys][match[:key_name]]}" unless (options[:keys].nil? || options[:keys][match[:key_name]].nil?)
+        hostname = match[:dns_name] || match[:public_ip_address] || match[:private_ip_address]
+        exec("ssh #{opt_key} #{options[:username]||'root'}@#{hostname}")
       else
         display "Typo alert! No server found!"
       end
@@ -124,6 +129,7 @@ module Ftl
     alias :ssh :connect
 
     def status(args={})
+      guard(args, :message => "Please provide the name/id of a server (ftl status <server>)")
       server = find_instance(args.first)
       display server
     end
@@ -150,11 +156,11 @@ module Ftl
         display "No instances found"
       end
     end
-    alias :d        :destroy 
-    alias :delete   :destroy 
-    alias :kill     :destroy 
-    alias :down     :destroy 
-    alias :shutdown :destroy 
+    alias :d        :destroy
+    alias :delete   :destroy
+    alias :kill     :destroy
+    alias :down     :destroy
+    alias :shutdown :destroy
 
     def info(args={})
       display find_instance(args.first)
@@ -171,9 +177,17 @@ module Ftl
       Formatador.display_table(con.images.find(:id => args.first))
     end
 
-    # TODO: Make images return only account's images by default
-    # def images(args={})
-    # end
+    # TODO: Make this better by including more details of block devices
+    def images(args={})
+      hashes = con.describe_images('Owner' => 'self').body['imagesSet'].collect do |hash|
+        h = {}
+        h[:image_id]  = hash['imageId']
+        h[:name]  = hash['name']
+        h[:rootDeviceType] = hash['rootDeviceType']
+        h
+      end 
+      puts Formatador.display_table(hashes)
+    end
 
     def headers(args={})
       display "Showing header options for #{args.first}"
@@ -189,12 +203,22 @@ module Ftl
       `$EDITOR ~/.ftl/ftl.yml`
     end
 
+    def sample(args={})
+      puts File.open(File.dirname(__FILE__) + "/../resources/ftl.yml").read
+    end
 
     ###########################################################################
     ## private                                                              ###
     ###########################################################################
     private
 
+    def guard(arg, options={:message => "Please refer to ftl help"})
+      if arg.nil?
+        display options[:message]
+        exit
+      end
+    end
+ 
     def ftl_yml
       File.open("lib/resources/ftl.yml").read
     end
@@ -208,11 +232,11 @@ module Ftl
         default_config_dir  = '/.ftl/'
         default_config_home = "#{ENV['HOME']}#{default_config_dir}"
         default_config_file = "#{default_config_home}#{default_config_name}"
-        if Dir.exist?(default_config_home) # Directory exists 
+        if Dir.exist?(default_config_home) # Directory exists
           if !File.exist?(default_config_file) # File does not
             File.open(default_config_file, 'w') {|f| f << ftl_yml }
           end
-        else # Directory does not exist 
+        else # Directory does not exist
           Dir.mkdir(default_config_home)
           File.open(default_config_file, 'w') {|f| f << ftl_yml }
         end
@@ -235,7 +259,7 @@ module Ftl
 
     def _headers_for(object)
       return options[:headers].map(&:to_sym) if options[:headers]
-      case object.to_sym
+      case object
       when :snapshots
         [:id, :volume_id, :state, :volume_size, :description, :"tags.Name"]
       when :spot_requests
@@ -258,16 +282,20 @@ module Ftl
       Formatador.display_line(msg)
     end
 
+    def eval_action(script, args)
+      # TODO Complete the script to handle multiple servers, like:
+      # ftl bundle server1 server2 server3
+      server = find_instance(args[1].first)
+      eval(script, binding)
+    end
+
     def method_missing(*args)
       begin
-        method = args.first
-        # opts = args[1]
-        if con.respond_to? method
-          display con.send(method).table(_headers_for(method))
-        else
-          Ftl.help
-        end
-      rescue 
+        method = args.first.to_sym
+        display con.send(method).table(_headers_for(method)) if con.respond_to? method
+        eval_action(@options[:actions][method], args) if @options[:actions][method]
+        Ftl.help
+      rescue
       end
     end
 

data/lib/ftl/version.rb

@@ -1,3 +1,3 @@
 module Ftl
-  VERSION = "0.2.3"
+  VERSION = "0.2.4"
 end

data/lib/resources/ftl.yml

@@ -1,20 +1,33 @@
+# Sample ftl.yml. Your ftl.yml should be located in ~/.ftl/ftl.yml and should
+#  look similar to this file
+# 
+# FILL IN THESE TWO VALUES
 ACCESS_KEY_ID: 
 SECRET_ACCESS_KEY: 
+
 :ami: ami-a29943cb # Ubuntu 12.04 LTS Precise Pangolin
 :username: ubuntu
-:instance_type: m1.small
-:instance_script: |
+:instance_type: t1.micro # m1.small 
+:user_data: |
   #!/bin/sh
   touch /root/file.touched
-:spinup_script: | 
+:post_script: | 
 :tags: {}
+:actions:
+  :uptime: puts server.ssh('uptime').first.stdout
+  :mount: puts server.ssh('mount').first.stdout
+  :df: puts server.ssh('df -h').first.stdout
+  :w: puts server.ssh('w').first.stdout
+
 
 :templates:
   :default:
     :ami: ami-a29943cb # Ubuntu 12.04 LTS Precise Pangolin
     :username: ubuntu
     :instance_type: m1.small
-    :instance_script: |
+    :user_data: |
       #!/bin/sh
       touch /root/file.touched
-    :spinup_script: | 
+    :post_script: | 
+
+

metadata

@@ -1,79 +1,82 @@
---- !ruby/object:Gem::Specification
+--- !ruby/object:Gem::Specification 
 name: ftl
-version: !ruby/object:Gem::Version
-  version: 0.2.3
+version: !ruby/object:Gem::Version 
   prerelease: 
+  version: 0.2.4
 platform: ruby
-authors:
+authors: 
 - Matt Petty
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-05-18 00:00:00.000000000 Z
-dependencies:
-- !ruby/object:Gem::Dependency
+
+date: 2012-07-15 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
   name: rdoc
-  requirement: &70186162145440 !ruby/object:Gem::Requirement
+  requirement: &id001 !ruby/object:Gem::Requirement 
     none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '0'
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
   type: :development
   prerelease: false
-  version_requirements: *70186162145440
-- !ruby/object:Gem::Dependency
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
   name: aruba
-  requirement: &70186162190980 !ruby/object:Gem::Requirement
+  requirement: &id002 !ruby/object:Gem::Requirement 
     none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '0'
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
   type: :development
   prerelease: false
-  version_requirements: *70186162190980
-- !ruby/object:Gem::Dependency
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
   name: rake
-  requirement: &70186162190220 !ruby/object:Gem::Requirement
+  requirement: &id003 !ruby/object:Gem::Requirement 
     none: false
-    requirements:
+    requirements: 
     - - ~>
-      - !ruby/object:Gem::Version
+      - !ruby/object:Gem::Version 
         version: 0.9.2
   type: :development
   prerelease: false
-  version_requirements: *70186162190220
-- !ruby/object:Gem::Dependency
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
   name: fog
-  requirement: &70186162189420 !ruby/object:Gem::Requirement
+  requirement: &id004 !ruby/object:Gem::Requirement 
     none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '0'
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
   type: :runtime
   prerelease: false
-  version_requirements: *70186162189420
-- !ruby/object:Gem::Dependency
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
   name: formatador
-  requirement: &70186162188520 !ruby/object:Gem::Requirement
+  requirement: &id005 !ruby/object:Gem::Requirement 
     none: false
-    requirements:
+    requirements: 
     - - ~>
-      - !ruby/object:Gem::Version
+      - !ruby/object:Gem::Version 
         version: 0.2.2
   type: :runtime
   prerelease: false
-  version_requirements: *70186162188520
+  version_requirements: *id005
 description: Ftl is a command line tool for Fog/AWS
-email:
+email: 
 - matt@kizmeta.com
-executables:
+executables: 
 - ftl
 extensions: []
+
 extra_rdoc_files: []
-files:
+
+files: 
 - .gitignore
 - Changelog
 - Gemfile
@@ -98,35 +101,38 @@ files:
 - test/tc_something.rb
 homepage: http://github.com/lodestone/ftl
 licenses: []
+
 post_install_message: 
 rdoc_options: []
-require_paths:
+
+require_paths: 
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement
+required_ruby_version: !ruby/object:Gem::Requirement 
   none: false
-  requirements:
-  - - ! '>='
-    - !ruby/object:Gem::Version
-      version: '0'
-      segments:
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: -3514707693365094716
+      segments: 
       - 0
-      hash: 1941961806599830985
-required_rubygems_version: !ruby/object:Gem::Requirement
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
   none: false
-  requirements:
-  - - ! '>='
-    - !ruby/object:Gem::Version
-      version: '0'
-      segments:
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: -3514707693365094716
+      segments: 
       - 0
-      hash: 1941961806599830985
+      version: "0"
 requirements: []
+
 rubyforge_project: 
 rubygems_version: 1.8.11
 signing_key: 
 specification_version: 3
 summary: Ftl is a command line tool for Fog/AWS
-test_files:
+test_files: 
 - features/ftl.feature
 - features/step_definitions/ftl_steps.rb
 - features/support/env.rb