slugforge 4.0.0

data/lib/slugforge/helper/build.rb

@@ -0,0 +1,46 @@
+module Slugforge
+  module Helper
+    module Build
+      def verify_procfile_exists!
+        unless File.exist?(project_path('Procfile'))
+          logger.say_status :warning, "Slugforge should normally be run in a project with a Procfile (#{project_path('Procfile')})", :yellow
+        end
+      end
+
+      def ruby_version_specified?
+        options[:ruby] and !options[:ruby].empty?
+      end
+
+      def has_ruby_version_file?
+        File.exist?(project_path('.ruby-version'))
+      end
+
+      def get_ruby_version_from_file
+        ruby_version = read_from_file
+        if ruby_version.nil? or ruby_version.empty?
+          raise error_class, "You don't have a ruby version specified in your .ruby-version file!!! Why you no set ruby version."
+        else
+          return ruby_version
+        end
+      end
+
+      def read_from_file
+        begin
+          File.read(project_path('.ruby-version')).delete("\n")
+        rescue Exception => e
+          raise error_class, "There were issues reading the .ruby-version file. Make sure it exists in the project path and it has valid content, #{e}."
+        end
+      end
+
+      def package_file_name
+        "#{project_name}-#{date_stamp}-#{git_sha}.slug"
+      end
+
+      def date_stamp
+        # Keep this as a class variable so the date stamp remains the same throughought the lifecycle of the app.
+        @@date_stamp ||= Time.now.strftime('%Y%m%d%H%M%S')
+      end
+    end
+  end
+end
+

data/lib/slugforge/helper/config.rb

@@ -0,0 +1,37 @@
+module Slugforge
+  module Helper
+    module Config
+      def self.included(base)
+        base.class_option :'aws-access-key-id', :type => :string, :aliases => '-I', :group => :config,
+          :desc => 'The AWS Access ID to use for hosts and buckets, unless overridden'
+        base.class_option :'aws-secret-key', :type => :string, :aliases => '-S', :group => :config,
+          :desc => 'The AWS Secret Key to use for hosts and buckets, unless overridden'
+        base.class_option :'aws-region', :type => :string, :group => :config,
+          :desc => 'The AWS region to use for EC2 instances and buckets'
+        base.class_option :'slug-bucket', :type => :string, :group => :config,
+          :desc => 'The S3 bucket to store the slugs and tags in'
+        base.class_option :'aws-session-token', :type => :string, :group => :config,
+          :desc => 'The AWS Session Token to use for hosts and buckets'
+
+        base.class_option :project, :type => :string, :aliases => '-P', :group => :config,
+          :desc => 'The name of the project as it exists in Slugforge. See the Project Naming section in the main help.'
+
+        base.class_option :'ssh-username', :type => :string, :aliases => '-u', :group => :config,
+          :desc => 'The account used to log in to the host (requires sudo privileges)'
+
+        base.class_option :'disable-slugins', :type => :boolean, :group => :config,
+          :desc => 'Disable slugin loading'
+
+        base.class_option :verbose, :type => :boolean, :aliases => '-V', :group => :runtime,
+          :desc => 'Display verbose output'
+        base.class_option :json, :type => :boolean, :aliases => '-j', :group => :runtime,
+          :desc => 'Display JSON output'
+
+        # Options intended for slugforge developers
+        base.class_option :test, :type => :boolean, :group => :runtime, :hide => true,
+          :desc => 'Test mode. Behaves like --pretend but triggers notifications and side effects as if a real action was taken.'
+      end
+    end
+  end
+end
+

data/lib/slugforge/helper/enumerable.rb

@@ -0,0 +1,46 @@
+module Enumerable
+  def parallel_map
+    queue = Queue.new
+
+    self.map do |item|
+      Thread.new do
+        # NOTE: You can not do anything that is not thread safe in this block...
+        queue << yield(item)
+      end
+    end.each(&:join)
+
+    [].tap do |results|
+      results << queue.pop until queue.empty?
+    end
+  end
+
+  def parallel_map_with_index
+    queue = Queue.new
+
+    self.map.with_index do |item, index|
+      Thread.new do
+        # NOTE: You can not do anything that is not thread safe in this block...
+        queue << yield(item, index)
+      end
+    end.each(&:join)
+
+    [].tap do |results|
+      results << queue.pop until queue.empty?
+    end
+  end
+
+  def ordered_parallel_map
+    queue = Queue.new
+
+    self.map.with_index do |item, index|
+      Thread.new do
+        # NOTE: You can not do anything that is not thread safe in this block...
+        queue << [index, yield(item)]
+      end
+    end.each(&:join)
+
+    [].tap do |results|
+      results << queue.pop until queue.empty?
+    end.sort.map {|index, item| item }
+  end
+end

data/lib/slugforge/helper/fog.rb

@@ -0,0 +1,90 @@
+require 'fog'
+
+module Slugforge
+  module Helper
+    module Fog
+      def compute
+        @compute ||= ::Fog::Compute.new(aws_credentials.merge({
+          :region   => config.aws_region,
+          :provider => 'AWS'
+        }))
+      end
+
+      def autoscaling
+        @autoscaling ||= ::Fog::AWS::AutoScaling.new(aws_credentials)
+      end
+
+      def s3
+        @s3 ||= ::Fog::Storage.new(aws_credentials.merge({
+          :provider => 'AWS'
+        }))
+      end
+
+      def aws_credentials
+        {
+          :aws_access_key_id     => verify_aws_config(config.aws_access_key, 'access key'),
+          :aws_secret_access_key => verify_aws_config(config.aws_secret_key, 'secret key'),
+          :aws_session_token     => config.aws_session_token
+        }.reject{ |_,v| v.nil? }
+      end
+
+      def aws_bucket
+        config.slug_bucket || raise(error_class, "You must specify a slug bucket in your configuration")
+      end
+
+      def expiring_url(file, expiration=nil)
+        expiration ||= Time.now + 60*60
+        file.url(expiration)
+      end
+
+      # Create a temporary AWS session
+      # @return [Hash] hash containing :access_key_id, :secret_access_key, :session_token
+      def aws_session(duration = 30)
+        @aws_session ||= begin
+          sts = ::Fog::AWS::STS.new(aws_credentials)
+
+          # Request a token for the user that has permissions masked to a single S3 bucket and only lasts a short time
+          token = sts.get_federation_token( username, bucket_policy, duration * 60 ) # session duration in minutes
+
+          {
+            aws_access_key_id:     token.body['AccessKeyId'],
+            aws_secret_access_key: token.body['SecretAccessKey'],
+            aws_session_token:     token.body['SessionToken'],
+            aws_region:            config.aws_region
+          }
+        end
+      end
+
+      private
+      def username
+        `whoami`.chomp
+      end
+
+      def verify_aws_config(variable, message)
+        raise error_class, "AWS #{message} is required to access AWS" unless variable
+        variable
+      end
+
+      def bucket_policy(bucket = aws_bucket)
+        {
+          "Version"   => "2012-10-17",
+          "Statement" => [
+            {
+              "Action"   => ["s3:*"],
+              "Effect"   => "Allow",
+              "Resource" => ["arn:aws:s3:::#{bucket}/*"]
+            },
+            {
+              "Action"   => [
+                "s3:ListBucket"
+              ],
+              "Effect"   => "Allow",
+              "Resource" => [ "arn:aws:s3:::#{bucket}" ]
+            }
+          ]
+        }
+      end
+    end
+  end
+end
+

data/lib/slugforge/helper/git.rb

@@ -0,0 +1,89 @@
+module Slugforge
+  module Helper
+    module Git
+
+      SHA_MAX_LENGTH = 10
+
+      def git_inside_work_tree?
+        return @git_inside_work_tree unless @git_inside_work_tree.nil?
+        @git_inside_work_tree = git_command('rev-parse --is-inside-work-tree') == 'true'
+      end
+
+      def git_user
+        @git_user ||= git_command('config github.user')
+      end
+
+      def git_account
+        return nil unless git_inside_work_tree? && !git_url.empty?
+        @git_account ||= git_url.match(%r|[:/]([^/]+)/[^/]+(\.git)?$|)[1]
+      end
+
+      def git_repository
+        return nil unless git_inside_work_tree? && !git_url.empty?
+        @git_repository ||= git_url.match(%r|/([^/]+?)(\.git)?$|)[1]
+      end
+
+      def git_branch
+        return nil unless git_inside_work_tree?
+        @git_branch ||= begin
+                          symbolic_ref = git_command('symbolic-ref HEAD')
+                          symbolic_ref.sub(%r|^refs/heads/|, '')
+                        end
+      end
+
+      def git_remote
+        return nil unless git_inside_work_tree?
+        @git_remote ||= git_command("config branch.#{git_branch}.remote")
+        # If we are headless just assume origin so that we can still detect other values
+        @git_remote.empty? ? 'origin' : @git_remote
+      end
+
+      def git_remote_sha(opts = {})
+        return nil unless git_inside_work_tree?
+        sha_length = opts[:sha_length] || SHA_MAX_LENGTH
+        url        = opts[:url] || git_url
+        branch     = opts[:branch] || git_branch
+
+        @git_remote_sha = begin
+                            if @git_remote_sha.nil? || opts[:memoize] == false
+                              output = git_command("ls-remote #{url} #{branch}").split(" ").first
+                              output =~ /^[0-9a-f]{40}$/i ? output : nil
+                            else
+                              @git_remote_sha
+                            end
+                          end
+
+        return @git_remote_sha.slice(0...sha_length) unless @git_remote_sha.nil?
+      end
+
+      def git_sha(opts = {})
+        raise error_class, "SHA can't be detected as this is not a git repository" unless git_inside_work_tree?
+        sha_length = opts[:sha_length] || SHA_MAX_LENGTH
+        @git_sha ||= git_command('rev-parse HEAD').chomp
+        @git_sha.slice(0...sha_length)
+      end
+
+      def git_url
+        return '' unless git_inside_work_tree?
+        @git_url ||= git_command("config remote.#{git_remote}.url")
+      end
+
+      def build_git_url(account, repository)
+        account    ||= git_account
+        repository ||= git_repository
+        "git@github.com:#{account}/#{repository}.git"
+      end
+
+      private
+      def git_command(cmd)
+        path = options[:path] ? "cd '#{options[:path]}' &&" : ""
+        `#{path} git #{cmd} 2> /dev/null`.chomp
+      end
+
+      def git_info
+        Hash[methods.select { |m| m.to_s =~/^git_/ }.map { |m| [ m.to_s, send(m) ] }]
+      end
+    end
+  end
+end
+

data/lib/slugforge/helper/path.rb

@@ -0,0 +1,76 @@
+require 'bundler'
+
+module Slugforge
+  module Helper
+    module Path
+      def self.included(base)
+        base.extend ClassMethods
+        base.source_root base.templates_dir
+      end
+
+      def project_path(*paths)
+        File.join(project_root, *paths)
+      end
+
+      def project_root
+        return @locate_project unless @locate_project.nil?
+        if options[:path] && Dir.exist?(File.expand_path(options[:path]))
+          return File.expand_path(options[:path])
+        end
+
+        path = File.expand_path(Dir.pwd)
+        paths = path.split('/')
+        until paths.empty?
+          if Dir.exist?(File.join(*paths, '.git'))
+            @locate_project = File.join(*paths)
+            return @locate_project
+          end
+
+          paths.pop
+        end
+        raise error_class, "Invalid path. Unable to find a .git project anywhere in path #{path}. Specify a path with --path."
+      end
+
+      def upstart_dir
+        @upstart_conf_dir ||= project_path('deploy', 'upstart').tap do |dir|
+                                FileUtils.mkdir_p(dir)
+                              end
+
+      end
+
+      def scripts_dir(*paths)
+        File.join(self.class.scripts_dir, *paths)
+      end
+
+      def templates_dir(*paths)
+        File.join(self.class.templates_dir, *paths)
+      end
+
+      def deploy_dir(*paths)
+        @deploy_dir ||= File.join('/opt', 'apps', project_name)
+        File.join(@deploy_dir, *paths)
+      end
+
+      def release_dir(*paths)
+        deploy_dir('releases', sha)
+      end
+
+      def system_with_path(cmd, path=nil)
+        path ||= options[:path]
+        cwd_command = path ? "cd #{path} && " : ""
+        ::Bundler.with_clean_env { system("#{cwd_command}#{cmd}") }
+      end
+
+      module ClassMethods
+        def scripts_dir
+          @scripts_dir ||= File.expand_path('../../../scripts', File.dirname(__FILE__))
+        end
+
+        def templates_dir
+          @templates_dir ||= File.expand_path('../../../templates', File.dirname(__FILE__))
+        end
+      end
+    end
+  end
+end
+

data/lib/slugforge/helper/project.rb

@@ -0,0 +1,86 @@
+module Slugforge
+  module Helper
+    module Project
+      def initialize(args=[], options={}, config={})
+        super
+        # Tracking the current command so we can be safe when creating projects
+        @current_command = config[:current_command]
+      end
+
+      protected
+      def tag_manager
+        @tag_manager ||= TagManager.new(:s3 => s3, :bucket => aws_bucket)
+      end
+
+      def bucket
+        @bucket ||= s3.directories.get(aws_bucket)
+      end
+
+      def project_name
+        # First one to return a value wins!
+        @project_name ||= config.project || git_repository
+        raise error_class, "Could not determine project name. This repository probably doesn't have an upstream branch yet. Please push your code, or specify `--project` when running slugforge." if @project_name.nil?
+        @project_name
+      end
+
+      def verify_project_name!(project=nil, opts={})
+        project ||= project_name
+        tm = TagManager.new(:s3 => s3, :bucket => aws_bucket)
+        return if tm.projects.include?(project)
+        raise error_class, "Project name could not be determined" unless project
+      end
+
+      def files
+        # If a block is provided, filter the files before mapping them
+        files = block_given? ? yield(bucket.files) : bucket.files
+        Hash[files.parallel_map_with_index do |file, i|
+          key = file.key.split('/', 2)
+
+          file.attributes.merge!({
+            :index         => i,
+            :name          => key.last,
+            :project       => key.first,
+            :age           => (Time.now.to_f - file.last_modified.to_f),
+            :pretty_age    => format_age(file.last_modified),
+            :pretty_length => format_size(file.content_length)
+          })
+
+          [file.key, file]
+        end]
+      end
+
+      def slugs(project)
+        filter = Proc.new do |files|
+          result=[]
+          # Fog only #maps against the first 1000 items, so we will use #each instead
+          files.each { |file| result << file if file.key =~ /^#{project}\/.*\.slug$/ } # ex match: project/blag.slug
+          result
+        end
+        files(&filter)
+      end
+
+      def find_latest_slug
+        self.slugs(project_name).values.sort_by { |s| s.last_modified }.last
+      end
+
+      # finds a slug with name_part somewhere in the name. Use enough of the name to make
+      # it unique or this will just return the first slug it finds
+      def find_slug(name_part)
+        s = self.slugs(project_name).values.find_all { |f| f.attributes[:key].include?(name_part) }
+        if s.size == 0
+          raise error_class, "unable to find a slug from '#{name_part}'. Use 'wrangler list' command to see available slugs"
+        elsif s.size > 1
+          raise error_class, "ambiguous slug name. Found more than one slug with '#{name_part}' in their names.\n#{s.map{|sl| File.basename(sl.key)} * "\n"}\n Use 'wrangler list' command to see available slugs"
+        end
+        s[0]
+      end
+
+      def find_slug_name(pattern)
+        slugs = self.slugs(project_name).values.select { |f| f.attributes[:key] =~ pattern }
+        return nil if slugs.empty?
+        slugs.sort_by { |s| s.last_modified }.last.key
+      end
+    end
+  end
+end
+