thor-tropo 1.4.0 → 2.0.0

data/README.md

@@ -1,6 +1,6 @@
 # Thor::Tropo
 
-TODO: Write a gem description
+Tool used to package released for Chef-Solo installs
 
 ## Installation
 
@@ -16,9 +16,79 @@ Or install it yourself as:
 
     $ gem install thor-tropo
 
+Include in your Thorfile
+
+include "tropo-tropo"
+
+### Config
+
+Thor-Tropo expects a `.deployer` file and will traverse the path from . through ~ until it finds one.  The .deployer file format is as follows:
+
+    aws_key: xxxx
+    aws_secret: xxxxx
+    bucket_name: artifacts.bucket.com
+    project_name: tropo/12.2.1/cookbooks/functional_deployment
+    
+
+Inside your project you can add the following at the root of your `top level cookbook`, or as we like to call it, `deployment model`
+
+`~/my_deployment_model/.deploy`
+
+    project_name: tropo/12.2.1/cookbooks/my_deployment_model
+    cookbooks:
+      - runtime_server
+      - gateway_server    
+
+The important thing to know about .deploy files is that they are implemented as a "first win" type of search pattern.  So if you run Thor for your current working directory it will traverse the path all the way to your home directoy looking for .deployer files.  If it finds one, and it finds a known attribute, it will use that and ignore any higher values.
+
+
+#### Example
+
+~/.deployer
+
+    bucket_name: foo
+
+~/somewhere/.deployer
+    
+    bucket_name: bar
+
+If you run thor tropo:package from ~/somewhere/.deployer then the bucket_name value will be bar, becaue that is the first one it found and so it "wins".  The intent here was that you can store certain common config values globally by simply keeping a .deployer file in your home dir, and then only apply certain project specific settings inside source control with your deployment model.  Hacky? Probably.. But it works well for us :) 
+
 ## Usage
 
-TODO: Write usage instructions here
+    jdyer@retina:~ » thor help tropo:package
+    Usage:
+      thor tropo:package
+    
+    Options:
+      -b, [--berkspath=BERKSPATH]                # Berksfile path
+      -V, [--version-override=VERSION-OVERRIDE]  # Provide a version for cookbook archive
+      -f, [--force]                              # overwrite any files on s3 without confirmation
+      -I, [--iam-auth]                           # Use IAM roles for AWS authorization
+      -i, [--ignore-dirty]                       # Will ignore any dirty files in git repo and continue to package cookbooks
+      -k, [--keeplock]                           # Respect Berksfile.lock
+      -c, [--clean-cache]                        # Delete local Berkshelf cookbook cache
+      -n, [--no-op]                              # NO-OP mode, Won't actually upload anything.  Useful to see what would have happened
+    
+    Package cookbooks using Berkshelf and upload file to s3 bucket
+
+
+## Gotcha's
+
+#### Search Priorities
+
+Then you can run thor-tropo from the model project root once and it will package both cookbooks.  However there is some logic here...
+
+* Use path provided by user via --berkspath flag
+* If there is a Berksfile in the current working directory use that
+* Use .deployer file config for finding cookbooks to package ( Example below of this .deployer config )
+
+`~/my_deployment_model/.deploy`
+
+    project_name: tropo/12.2.1/cookbooks/my_deployment_model
+    cookbooks:
+      - runtime_server
+      - gateway_server    
 
 ## Contributing
 

data/changelog.md

@@ -1,3 +1,13 @@
+# 2.0.0
+
+* Support multiple cookbooks via .deployer
+* Support IAM profiles
+* Support --version / -v 
+* Support --help / -h
+* Better logging
+* Support git tagging via seperate task
+* Support cleaning berksfile cache
+
 # 1.4.0
 
 * Moved cookbook finder into it's own method, SRP :) 

data/lib/thor-tropo.rb

@@ -18,115 +18,221 @@ module ThorTropo
   class Tasks < Thor
     include Thor::Actions
 
+
     @packaged_cookbook = nil
 
+    @working_directory = nil
+    @invoke_directory = Dir.pwd
+
     namespace "tropo"
 
-    class_option :called_path,
+    class_option "help",
+      :type => :boolean,
+      :default => false,
+      :aliases => "-h"
+
+    class_option "version",
+      :type => :boolean,
+      :default => false,
+      :aliases => "-v"
+
+    desc "package", "Package cookbooks using Berkshelf and upload file to s3 bucket"
+
+    method_option :berkspath,
       :type    => :string,
-      :aliases => "-d",
-      :default => Dir.pwd,
-      :desc    => "Directory of your Berksfile",
-      :banner  => "Directory of your Berksfile"
+      :aliases => "-b",
+      :default => nil,
+      :desc    => "Berksfile path"
 
-    desc "package", "Package cookbooks and upload to S3"
+    #:banner  => "Path to find your cookbook Berksfile"
 
     method_option :"version-override",
       :type    => :string,
       :aliases => "-V",
       :default => nil,
-      :desc    => "Force override of version number",
-      :banner  => "Force override of cookbook version"
+      :desc    => "Provide a version for cookbook archive"
+
+    #:banner  => "Provider a cookbook version rather then using metadata.rb"
 
     method_option :force,
       :type    => :boolean,
       :aliases => "-f",
       :default => false,
-      :desc    => "Force override of any files on s3 without confirmation",
-      :banner  => "Force overrides of existing files"
+      :desc    => "overwrite any files on s3 without confirmation"
 
-    method_option :noop,
-      :type    => :boolean,
-      :aliases => "-n",
-      :default => false,
-      :desc    => "NO-OP mode, dont actually upload anything"
+    #:banner  => "Ignore existing files and overwrite without confirmation"
 
-    method_option :ignore_dirty,
+    method_option :"iam-auth",
+      :type     => :boolean,
+      :default  => false,
+      :aliases  => "-I",
+      :desc     => "Use IAM roles for AWS authorization"
+
+    #:banner   => "Will expect an IAM role is present for S3 Auth.  Useful for CI"
+
+    method_option :"ignore-dirty",
       :type     => :boolean,
       :aliases  => "-i",
       :default  => false,
-      :desc     => "Ignore any dirty files in directory and package anyways",
-      :banner   => "Ignore dirty repository"
+      :desc     => "Will ignore any dirty files in git repo and continue to package cookbooks"
+
+    #:banner   => "Ignore dirty git repository"
 
-    method_option :clean_mode,
+    method_option :keeplock,
+      :type     => :boolean,
+      :aliases  => "-k",
+      :default  => false,
+      :desc     => "Respect Berksfile.lock"
+
+    #:banner   => "Don't delete lockfile before running `Berks install`"
+
+    method_option :"clean-cache",
       :type     => :boolean,
       :aliases  => "-c",
       :default  => false,
-      :desc     => "Delete lockfile before running `Berks install`",
-      :banner   => "Delete lockfile before running `Berks install`"
+
+      #:banner     => "Delete Berkshelf cookbook cache",
+      :desc     => "Delete local Berkshelf cookbook cache"
+
+    method_option :"no-op",
+      :type    => :boolean,
+      :aliases => "-n",
+      :default => false,
+      :desc    => "NO-OP mode, Won't actually upload anything.  Useful to see what would have happened"
+    #:banner    => "NO-OP mode",
+
 
     def package
 
-      #$config = ThorTropo::Configuration.new(options[:called_path])
+      print_help_or_version
+
       $config = ThorTropo::Configuration.new(source_root)
 
       unless clean?
-        unless options[:ignore_dirty]
-          say "There are files that need to be committed first.", :red
-          exit 1
-        end
+        say "[ TROPO ] - There are files that need to be committed first.", :red
+        exit 1 unless options[:"ignore-dirty"]
       end
 
-      tag_version {
+      clean_berks_cache if options[:"clean-cache"]
+
+      if path_priorities
         bundle_cookbook
-        upload_cookbook @packaged_cookbook, $config.project_name, {:force => options[:force],:noop => options[:noop]}
-      }
+        upload_cookbook @packaged_cookbook, $config.project_name, {:force => options[:force],:"no-op" => options[:"no-op"]}
+      else
+        if $config.cookbooks.is_a? Array
+          say "[ TROPO ] - Found multiple cookbooks, packaging individual projects", :cyan
+          home = Dir.pwd
+
+          $config.cookbooks.each do |cookbook|
+            break if options[:path]
+            @working_directory = File.expand_path(File.join(home,cookbook))
+            say "[ TROPO ] - Switcing to #{@working_directory}", :blue
+            Dir.chdir(@working_directory)
+            bundle_cookbook
+            upload_cookbook @packaged_cookbook, $config.project_name, {:force => options[:force],:noop => options[:"no-op"]}
+            #@working_directory = nil
+          end
+        end
+      end
+
+    end
+
 
+    desc "tag", "Tag release"
+
+    method_option :version,
+      :type     => :string,
+      :aliases  => "-v",
+      :default  => nil,
+      :required => true,
+      :desc     => "Set a tag for the release and push to remote",
+      :desc     => "Set a tag for the release and push to remote"
+    def tag
+      print_help_or_version
+
+      if File.exists?(".git")
+        tag_version options[:version]
+      else
+        say "[ TROPO ] - Directory is not managed by Git, quiting..", :red
+        exit 1
+      end
     end
 
     no_tasks do
 
+
+      def print_help_or_version
+        if options[:help]
+          help "package"
+          exit 0
+        elsif options[:version]
+          say "[ TROPO ] Version - #{ThorTropo::VERSION}", :blue
+          exit 0
+        end
+      end
+      def path_priorities
+        if options[:berkspath]
+          say "[ TROPO ] - Detected Berkspath was provided, so we will use this", :blue
+          ### User specified berkspath, this is highest priority
+          @working_directory = File.expand_path(options[:berkspath])
+        elsif Dir.glob("*").include?("Berksfile")
+          say "[ TROPO ] - Detected Berksfile in current directory and no --berkspath was provided.  We'll use local Berksfile.", :blue
+          ### Found berksfile in working directory
+          @working_directory = File.expand_path(".")
+        end
+
+      end
+
       def upload_cookbook(local_file,path,opts={})
         uploader = ThorTropo::Uploader.new({
                                              :access_key => $config.aws_key,
                                              :secret_key => $config.aws_secret,
-                                             :bucket     => $config.bucket_name
+                                             :bucket     => $config.bucket_name,
+                                             :use_iam    => options[:"iam-auth"]
         })
 
-        uploader.upload :local_file => local_file, :path => path, :force => options[:force], :noop=>options[:noop]
+        uploader.upload :local_file => local_file, :path => path, :force => options[:force], :noop => options[:"no-op"]
+      end
+
+      def clean_berks_cache
+        say "[ TROPO ] - Clearing local Berkshelf cookbook cache", :green
+
+        unless options[:"no-op"]
+          remove_dir (File.expand_path(File.join(Dir.home,".berkshelf","cookbooks")))
+        end
       end
 
       def clean?
-        #sh_with_excode("cd #{options[:called_path]}; git diff --exit-code")[1] == 0
         sh_with_excode("cd #{source_root}; git diff --exit-code")[1] == 0
       end
 
       def clean_lockfile
-        #berksfile = "#{options[:called_path]}/Berksfile.lock"
         berksfile = "#{source_root}/Berksfile.lock"
 
         if File.exists? berksfile
           say "[ TROPO ] - Removing Berksfile.lock before running Berkshelf", :blue
-          remove_file(berksfile) unless options[:noop]
+          remove_file(berksfile) unless options[:"no-op"]
         else
           say "[ TROPO ] - Unable to find berksfile to delete - [ #{berksfile} ]", :yellow
         end
       end
 
       def bundle_cookbook
-        clean_lockfile if options[:clean_mode]
-
-        say "[ TROPO ] - Packaging cookbooks from Berksfile", :blue
+        clean_lockfile unless options[:keeplock]
+        berksfile = File.join(source_root,"/Berksfile")
+        say "[ TROPO ] - Packaging cookbooks using #{berksfile}", :blue
         @tmp_dir = Dir.mktmpdir
         opts = {
-          #berksfile: File.join(options[:called_path],"/Berksfile"),
-          berksfile: File.join(source_root,"/Berksfile"),
+          berksfile: berksfile,
           path: "#{@tmp_dir}/cookbooks"
         }
 
+        Dir.chdir File.dirname(berksfile)
         invoke("berkshelf:install", [], opts)
-        #output   = File.expand_path(File.join(@tmp_dir, "#{options[:called_path].split("/")[-1]}-#{current_version}.tar.gz"))
-        output   = File.expand_path(File.join(@tmp_dir, "#{cookbook_name}-#{current_version}.tar.gz"))
+
+        @_invocations.except!(Berkshelf::Cli) ### Clear Berkshelf from invocations array, because apperently you can't invoke the same task twice...
+
+        output   = File.expand_path(File.join(@tmp_dir, "#{get_cookbook_name}-#{current_version}.tar.gz"))
 
         Dir.chdir(@tmp_dir) do |dir|
           tgz = Zlib::GzipWriter.new(File.open(output, 'wb'))
@@ -136,7 +242,7 @@ module ThorTropo
 
       end
 
-      def cookbook_name
+      def get_cookbook_name
         source_root.split("/")[-1]
       end
 
@@ -144,28 +250,33 @@ module ThorTropo
         if options[:"version-override"]
           options[:"version-override"]
         else
-          #metadata = Ridley::Chef::Cookbook::Metadata.from_file(File.join(options[:called_path],"metadata.rb"))
+
           metadata = Ridley::Chef::Cookbook::Metadata.from_file(File.join(source_root,"metadata.rb"))
           metadata.version
         end
       end
 
-      def tag_version
-        sh "git tag -a -m \"Version #{current_version}\" #{current_version}" unless options[:noop]
-        say "[ TROPO ] - Tagged: #{current_version}", :blue
+      def tag_version(version=nil)
+        git_tag = version || current_version
+        sh "git tag -a -m \"Version #{git_tag}\" #{git_tag}" unless options[:"no-op"]
+        say "[ TROPO ] - Tagged: #{git_tag}", :blue
         yield if block_given?
-        sh "git push --tags" unless options[:noop]
+        sh "git push --tags" unless options[:"no-op"]
       rescue => e
-        say "[ TROPO ] - Untagging: #{current_version} due to error", :red
-        sh_with_excode "git tag -d #{current_version}"
+        say "[ TROPO ] - Untagging: #{git_tag} due to error", :red
+        sh_with_excode "git tag -d #{git_tag}"
         say "[ TROPO ] - #{e}", :red
         exit 1
       end
 
       ## Get the directory to Berksfile
       def source_root
+        berks_path = unless options[:berkspath]
+          Dir.pwd
+        else
+          @working_directory || File.expand_path(options[:berkspath])
+        end
 
-        berks_path = File.expand_path(options[:called_path])
         if File.exists? berks_path
           berks_path
         else

data/lib/thor-tropo/configuration.rb

@@ -6,7 +6,7 @@ module ThorTropo
     require 'pathname'
     require 'yaml'
 
-    attr_reader :bucket_name, :aws_secret, :aws_key, :project_name
+    attr_reader :bucket_name, :aws_secret, :aws_key, :project_name, :cookbooks
 
     def initialize(path)
       file_name=".deployer"
@@ -40,6 +40,10 @@ module ThorTropo
         @project_name = config['project_name'] unless @project_name
       end
 
+      if config['cookbooks']
+        @cookbooks = config['cookbooks'] unless @cookbooks
+      end
+
     end
   }
 

data/lib/thor-tropo/uploader.rb

@@ -13,6 +13,7 @@ module ThorTropo
         @debug_mode   = opts[:debug_mode]
         @connection   = setup_connection(opts[:access_key],opts[:secret_key])
         @bucket_name  = get_bucket( opts[:bucket] || 'artifacts.voxeolabs.net' )
+        @use_iam      = opts[:use_iam]
       end
 
       def upload(opts={})
@@ -56,11 +57,19 @@ module ThorTropo
       private
 
       def setup_connection(u,p)
-        Fog::Storage.new({
+        if @use_iam
+          opts = {
+            :provider        => 'AWS',
+            :use_iam_profile => true
+          }
+        else
+          opts = {
             :provider                 => 'AWS',
             :aws_access_key_id        => u,
             :aws_secret_access_key    => p
-        })
+          }
+        end
+        Fog::Storage.new(opts)
       end
 
       def get_bucket(bucket_name)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: thor-tropo
 version: !ruby/object:Gem::Version
-  version: 1.4.0
+  version: 2.0.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-07-15 00:00:00.000000000 Z
+date: 2013-07-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: chef