jara 2.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: dd7d9d3308929fa4978ae10bd2bd071d3a39610c
+  data.tar.gz: c2cf848a765a20264026e3858e6700c5923bc184
+SHA512:
+  metadata.gz: c3e7c6e1f2a056b112606a409901252e5d14991254db3bd1b6c81a2f6f37d1b55841a3dece7ddf13426b36e8e7345df1143025f05276207ddcef83372c4f948b
+  data.tar.gz: 64a121477496d10d2fc695a9fa1c0ebcb229436502c9dfeaa62aa9ce18ac50ba152c388a695960faa89999761377774d12957b3f96ee75c11ea34af48edac1ba

data/LICENSE.txt

@@ -0,0 +1,12 @@
+Copyright (c) 2014, Burt AB
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

data/README.md

@@ -0,0 +1,122 @@
+# Jarå
+
+Jarå creates clean artifacts from Git repositories and publishes them to S3. It will check that you've pushed your code, check out a pristine copy from git, build an artifact and upload it to S3 using a name that includes the date, time and Git SHA.
+
+In JRuby it can use [Puck](https://github.com/iconara/puck) to create a standalone JAR file that can be run with `java -jar …`.
+
+# Installation
+
+```ruby
+group :development do
+  gem 'jara'
+  gem 'puck', platform: 'jruby'
+end
+```
+
+Puck is optional, and only available in JRuby. If Puck is present it will be the default archiver (see below for how to configure this).
+
+# Usage
+
+You can use Jarå either from a `Rakefile` or from the command line. Here's an example from a `Rakefile` that builds an artifact from the master branch and uploads it to the `artifact-bucket` S3 bucket:
+
+```ruby
+task :release do
+  releaser = Jarå::Releaser.new('production', 'artifact-bucket')
+  releaser.release
+end
+```
+
+## Release names
+
+The JAR artifact will be named from the project name, environment, date stamp and commit SHA, and will be uploaded with a path on S3 that also contains the environment and project name. The name of the directory that contains the code is assumed to be the project name.
+
+For example, if you run it from a directory called "foo_bar" and sets the environment "production" it will build the artifact "foo_bar-production-YYYYmmddHHMMSS-XXXXXXXX.jar", where "YYYYmmddHHMMSS" is the current date and time and "XXXXXXXX" is the first 8 characters from the commit SHA. The artifact will be cached locally in a directory called "build/production" and then uploaded to S3 into the specified bucket, with the key "production/foo_bar/foo_bar-production-YYYYmmddHHMMSS-XXXXXXXX.jar".
+
+If you change "production" to "staging" it will build an artifact from the staging branch instead (and all other paths and names will have "staging" where they had "production" in the description above).
+
+You may have noticed that specifying "production" created an artifact from the master branch, and "staging" used the staging branch. Using anything but "production" means that the branch name is assumed to be the same as the environment.
+
+Before the artifact is built Jarå will check that _branch_name_ and origin/*branch_name* point to the same commit. The reason for this is so that you don't release an artifact with a SHA that is not visible to others (this does not check that you've pulled before you release, but the important thing is to not release something that is not trackable).
+
+## Using the command line tool
+
+The same can be accomplished by running this from the command line:
+
+```
+$ jara release --environment production --bucket artifact-bucket
+```
+
+## Building tarballs
+
+The primary use case for Jarå is building self contained JAR files, but it can also be used to create tarballs. This can be useful for non-Ruby projects that you want to release the same way you release your JRuby applications.
+
+If you would rather build a tarball you can do that like this:
+
+```ruby
+task :tarball do
+  releaser = Jarå::Releaser.new('production', 'artifact-bucket', archiver: :tgz)
+  releaser.release
+end
+```
+
+or from the command line:
+
+```
+$ jara release --environment production --bucket artifact-bucket --archiver tgz
+```
+
+The `tgz` archiver is the default when Puck is not installed.
+
+Sometimes your source code isn't enough to run the application. If you're using Jarå to create a tarball of a purely client side web application you might want to minify all JavaScript and CSS files before the artifact is created. This can be done like this (assuming you have a `Makefile` with a `minify` target):
+
+```ruby
+task :tarball do
+  releaser = Jarå::Releaser.new('production', 'artifact-bucket', archiver: :tgz, build_command: 'make minify')
+  releaser.release
+end
+```
+
+The command can also be a Ruby proc, or anything that responds to `#call`:
+
+```ruby
+task :tarball do
+  build_command = lambda do
+    FileUtils.touch('very-important-file')
+  end
+  releaser = Jarå::Releaser.new('production', 'artifact-bucket', archiver: :tgz, build_command: build_command)
+  releaser.release
+end
+```
+
+or from the command line:
+
+```
+$ jara release --environment production --bucket artifact-bucket --archiver tgz --build-command 'make minify'
+```
+
+The command can be anything, as long as it can run from a cleanly checked out version of your repository.
+
+## Just building an artifact
+
+If you don't want to release an artifact to S3 you can choose to just build one (you don't need to specify the bucket name if you're only building an artifact):
+
+```ruby
+task :artifact do
+  releaser = Jarå::Releaser.new('production')
+  releaser.build_artifact
+end
+```
+
+and from the command line:
+
+```
+$ jara build --environment production
+```
+
+## Build from the working directory
+
+In all of the examples above Jarå has checked out a clean copy of your code before building the artifact, but in some cases you just want to pack up everything and see if it works. In those cases you can set the environment to `nil` (or leave out the `--environment` option) to build from the working directory directly. The artifact will be placed directly under the `build` directory and it will be named just after the project directory, it will not have any timestamps nor commit SHA in the name.
+
+# Copyright
+
+© 2014-2015 Burt AB, see LICENSE.txt (BSD 3-Clause).

data/bin/jara

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+
+require 'jara/cli'
+
+Jara::Cli.new(ARGV).run

data/lib/jara/cli.rb

@@ -0,0 +1,60 @@
+# encoding: utf-8
+
+require 'jara'
+require 'optparse'
+
+module Jara
+  class Cli
+    def initialize(argv)
+      @command = argv.first
+      @argv = argv.drop(1)
+    end
+
+    def run
+      parse_argv(@argv)
+      options = {}
+      options[:archiver] = @archiver if @archiver
+      options[:build_command] = @build_command if @build_command
+      releaser = Jara::Releaser.new(@environment, @bucket, options)
+      case @command
+      when /help|-h/
+        $stderr.puts(option_parser)
+      when 'release'
+        releaser.release
+      when 'build'
+        releaser.build_artifact
+      else
+        $stderr.puts('Unknown command "%s", expected "build" or "release"' % @command)
+        exit(1)
+      end
+    rescue OptionParser::ParseError => e
+      $stderr.puts(option_parser)
+      exit(1)
+    rescue JaraError => e
+      $stderr.puts(sprintf('Could not %s artifact: %s', @command, e.message))
+      exit(1)
+    end
+
+    private
+
+    def option_parser
+      @option_parser ||= OptionParser.new do |parser|
+        parser.banner = "Usage: jara build [options]\n       jara release [options]"
+        parser.separator ''
+        parser.separator 'Common options:'
+        parser.on('-e', '--environment=ENV', 'Environment to release to (e.g. production, staging)') { |e| @environment = e }
+        parser.on('-a', '--archiver=TYPE', 'Archiver to use (jar or tgz)') { |t| @archiver = t.to_sym }
+        parser.on('-c', '--build-command=COMMAND', 'Command to run before creating the artifact') { |c| @build_command = c }
+        parser.on('-h', '--help', 'Show this message') { @command = 'help' }
+        parser.separator ''
+        parser.separator 'Release options:'
+        parser.on('-b', '--bucket=BUCKET', 'S3 bucket for releases') { |b| @bucket = b }
+        parser.separator ''
+      end
+    end
+
+    def parse_argv(argv)
+      option_parser.parse(argv)
+    end
+  end
+end

data/lib/jara/releaser.rb

@@ -0,0 +1,281 @@
+# encoding: utf-8
+
+require 'tmpdir'
+require 'fileutils'
+require 'pathname'
+require 'digest/md5'
+require 'aws-sdk-core'
+require 'socket'
+
+
+module Jara
+  ExecError = Class.new(JaraError)
+
+  class Releaser
+    def initialize(environment, bucket_name=nil, options={})
+      @environment = environment
+      @bucket_name = bucket_name
+      @re_release = options.fetch(:re_release, false)
+      @extra_metadata = options[:metadata] || {}
+      @build_command = options[:build_command]
+      @shell = options[:shell] || Shell.new
+      @archiver = create_archiver(options[:archiver])
+      @file_system = options[:file_system] || FileUtils
+      @s3 = options[:s3]
+      @logger = options[:logger] || IoLogger.new($stderr)
+      @branch = @environment == 'production' ? 'master' : @environment
+    end
+
+    def build_artifact
+      if @environment.nil?
+        archive_name = "#{app_name}.#{@archiver.extension}"
+        Dir.chdir(project_dir) do
+          @archiver.create(archive_name: archive_name)
+        end
+        @logger.info('Created test artifact')
+        File.join(project_dir, 'build', archive_name)
+      elsif (artifact_path = find_local_artifact)
+        @logger.warn('An artifact for %s already exists: %s' % [branch_sha[0, 8], File.basename(artifact_path)])
+        artifact_path
+      else
+        date_stamp = Time.now.utc.strftime('%Y%m%d%H%M%S')
+        destination_dir = File.join(project_dir, 'build', @environment)
+        archive_name = [app_name, @environment, date_stamp, branch_sha[0, 8]].join('-') << '.' << @archiver.extension
+        Dir.mktmpdir do |path|
+          @shell.exec('git archive --format=tar --prefix=%s/ %s | (cd %s/ && tar xf -)' % [File.basename(path), branch_sha, File.dirname(path)])
+          Dir.chdir(path) do
+            @logger.info('Checked out %s from branch %s' % [branch_sha[0, 8], @branch])
+            if @build_command
+              if @build_command.respond_to?(:call)
+                @logger.info('Running build command')
+                @build_command.call
+              else
+                @logger.info('Running build command: %s' % @build_command)
+                @shell.exec(@build_command)
+              end
+            end
+            @archiver.create(archive_name: archive_name)
+            @file_system.mkdir_p(destination_dir)
+            @file_system.cp("build/#{archive_name}", destination_dir)
+            @logger.info('Created artifact %s' % archive_name)
+          end
+        end
+        File.join(destination_dir, archive_name)
+      end
+    end
+
+    def release
+      raise JaraError, 'No environment set' unless @environment
+      raise JaraError, 'No bucket name set' unless @bucket_name
+      if !@re_release && (obj = find_remote_artifact)
+        s3_uri = 's3://%s/%s' % [@bucket_name, obj.key]
+        @logger.warn('An artifact for %s already exists: %s' % [branch_sha[0, 8], s3_uri])
+        s3_uri
+      else
+        local_path = find_local_artifact || build_artifact
+        upload_artifact(local_path)
+      end
+    end
+
+    private
+
+    def s3
+      @s3 ||= Aws::S3::Client.new
+    end
+
+    def app_name
+      File.basename(project_dir)
+    end
+
+    def project_dir
+      unless defined? @project_dir
+        Pathname.new(Dir.getwd).descend do |path|
+          if Dir.entries(path).include?('.git')
+            @project_dir = path
+            break
+          end
+        end
+        unless defined? @project_dir
+          raise JaraError, 'Could not find project directory'
+        end
+      end
+      @project_dir
+    end
+
+    def branch_sha
+      @branch_sha ||= begin
+        result = @shell.exec('git rev-parse %s && git rev-parse origin/%s' % [@branch, @branch])
+        local_sha, remote_sha = result.split("\n").take(2)
+        if local_sha == remote_sha
+          local_sha
+        else
+          raise JaraError, '%s and origin/%s are not in sync, did you forget to push?' % [@branch, @branch]
+        end
+      end
+    end
+
+    def git_remote
+      @git_remote ||= @shell.exec('git config --get remote.origin.url')
+    end
+
+    def metadata
+      m = {
+        'packaged_by' => "#{ENV['USER']}@#{Socket.gethostname}",
+        'sha' => branch_sha,
+        'remote' => git_remote,
+      }
+      m.merge!(@extra_metadata)
+      m.merge!(@archiver.metadata)
+      m
+    end
+
+    def find_local_artifact
+      candidates = Dir[File.join(project_dir, 'build', @environment, "*.#{@archiver.extension}")]
+      candidates.select! { |path| path.include?(branch_sha[0, 8]) }
+      candidates.sort.last
+    end
+
+    def upload_artifact(local_path)
+      remote_path = [@environment, app_name, File.basename(local_path)].join('/')
+      content_md5 = Digest::MD5.file(local_path).base64digest
+      File.open(local_path, 'rb') do |io|
+        s3.put_object(
+          bucket: @bucket_name,
+          key: remote_path,
+          content_type: @archiver.content_type,
+          content_md5: content_md5,
+          metadata: metadata,
+          body: io,
+        )
+      end
+      s3_uri = 's3://%s/%s' % [@bucket_name, remote_path]
+      @logger.info('Artifact uploaded to %s' % s3_uri)
+      s3_uri
+    end
+
+    def find_remote_artifact
+      listing = s3.list_objects(bucket: @bucket_name, prefix: [@environment, app_name, "#{app_name}-#{@environment}-"].join('/'))
+      listing.contents.find { |obj| obj.key.include?(branch_sha[0, 8]) }
+    end
+
+    def create_archiver(archiver)
+      case archiver
+      when :puck, :jar
+        PuckArchiver.new(@shell)
+      when :tar, :tgz
+        Tarchiver.new(@shell)
+      when nil
+        if defined? PuckArchiver
+          create_archiver(:puck)
+        else
+          create_archiver(:tgz)
+        end
+      else
+        archiver
+      end
+    end
+
+    class Shell
+      def exec(command)
+        output = %x(#{command})
+        unless $?.success?
+          raise ExecError, %(Command `#{command}` failed with output: #{output})
+        end
+        output
+      rescue Errno::ENOENT => e
+        raise ExecError, %(Command `#{command}` failed: #{e.message})
+      end
+    end
+
+    class Archiver
+      def initialize(shell)
+        @shell = shell
+      end
+
+      def create(options)
+      end
+
+      def extension
+      end
+
+      def content_type
+      end
+
+      def metadata
+        {}
+      end
+    end
+
+    class Tarchiver < Archiver
+      def create(options)
+        FileUtils.mkdir_p('build')
+        entries = Dir['*']
+        entries.delete('build')
+        @shell.exec("tar czf build/#{options[:archive_name]} #{entries.join(' ')}")
+      end
+
+      def extension
+        'tgz'
+      end
+
+      def content_type
+        'application/x-gzip'
+      end
+    end
+
+    if defined? JRUBY_VERSION
+      begin
+        require 'puck'
+
+        class PuckArchiver < Archiver
+          def create(options)
+            options = options.dup
+            options[:jar_name] = options.delete(:archive_name)
+            Puck::Jar.new(options).create!
+          end
+
+          def extension
+            'jar'
+          end
+
+          def content_type
+            'application/java-archive'
+          end
+
+          def metadata
+            jruby_jars_path = $LOAD_PATH.grep(/\/jruby-jars/).first
+            jruby_version = jruby_jars_path && jruby_jars_path.scan(/\/jruby-jars-(.+)\//).flatten.first
+            if jruby_version
+              super.merge('jruby' => jruby_version)
+            else
+              super
+            end
+          end
+        end
+      rescue LoadError => e
+        raise unless e.message.include?('no such file to load -- puck')
+      end
+    end
+  end
+
+  class IoLogger
+    def initialize(io)
+      @io = io
+    end
+
+    def info(msg)
+      @io.puts(msg)
+    end
+
+    def warn(msg)
+      @io.puts(msg)
+    end
+  end
+
+  class NullLogger
+    def info(*); end
+    def warn(*); end
+  end
+
+  NULL_LOGGER = NullLogger.new
+end

data/lib/jara/version.rb

@@ -0,0 +1,5 @@
+# encoding: utf-8
+
+module Jara
+  VERSION = '2.0.0'.freeze
+end

data/lib/jara.rb

@@ -0,0 +1,9 @@
+# encoding: utf-8
+
+module Jara
+  JaraError = Class.new(StandardError)
+end
+
+Jarå = Jara
+
+require 'jara/releaser'

metadata

@@ -0,0 +1,69 @@
+--- !ruby/object:Gem::Specification
+name: jara
+version: !ruby/object:Gem::Version
+  version: 2.0.0
+platform: ruby
+authors:
+- Burt Platform Team
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2015-02-13 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  name: aws-sdk-core
+  prerelease: false
+  type: :runtime
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: |-
+  Jara is a tool for building artifacts from a Git
+                         repository, and can make standalone Jar files for JRuby.
+                         It will check out a clean copy of your code and name
+                         the artifact from the commit it was built from.
+email:
+- theo@burtcorp.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE.txt
+- README.md
+- bin/jara
+- lib/jara.rb
+- lib/jara/cli.rb
+- lib/jara/releaser.rb
+- lib/jara/version.rb
+homepage: http://github.com/burtcorp/jara
+licenses:
+- BSD-3-Clause
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: 1.9.3
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project:
+rubygems_version: 2.2.2
+signing_key:
+specification_version: 4
+summary: Builds and publishes project artifacts
+test_files: []