mason 0.0.1

data/README.md

@@ -0,0 +1,53 @@
+# Mason
+
+Build things
+
+## Instructions
+
+### Install buildpacks locally
+
+	$ mason buildpacks
+	* buildpacks (~/.mason/buildpacks)
+	  = foo: https://github.com/ddollar/buildpack-foo.git
+	  = bar: https://github.com/ddollar/buildpack-bar.git
+
+	$ mason buildpacks:install https://github.com/ddollar/buildpack-baz.git
+	* adding buildpack https://github.com/ddollar/buildpack-baz.git
+
+### Use buildpacks to build things
+
+	$ mason build /tmp/app
+	* detecting buildpack... done
+	  = name: Baz
+	  = url: https://github.com/ddollar/buildpack-baz.git
+	* compiling:
+	... COMPILE OUTPUT
+	* packaging... done
+	  = type: squashfs
+	  = file: /tmp/app.img
+
+	$ mason build /tmp/app -t dir -o /tmp/compiledapp
+	* detecting buildpack... done
+	  = name: Baz
+	  = url: https://github.com/ddollar/buildpack-baz.git
+	* compiling...
+	... COMPILE OUTPUT
+	* packaging... done
+	  = type: dir
+	  = dir: /tmp/compiledapp
+
+	$ mason build /tmp/app -b https://github.com/ddollar/buildpack-other.git -t tgz
+	* detecting buildpack... done
+	  = name: Other
+	  = url: https://github.com/ddollar/buildpack-other.git
+	* compiling...
+	... COMPILE OUTPUT
+	* packaging... done
+	  = type: tgz
+	  = file: /tmp/app.tgz
+
+### Use vagrant to build things for other platforms
+
+	$ mason build /tmp/app -s cedar
+	* booting vm for cedar
+	...

data/bin/mason

@@ -0,0 +1,13 @@
+#!/usr/bin/env ruby
+
+$:.unshift File.expand_path("../../lib", __FILE__)
+
+require "mason/cli"
+
+begin
+  Mason::CLI.run
+rescue Errno::EPIPE
+rescue Mason::CommandFailed => ex
+  $stderr.puts "  ! #{ex}"
+  exit 1
+end

data/data/Vagrantfile.template

@@ -0,0 +1,5 @@
+Vagrant::Config.run do |config|
+  config.vagrant.dotfile_name = File.expand_path("~/.mason/vagrant")
+
+BOXES
+end

data/lib/mason.rb

@@ -0,0 +1,5 @@
+module Mason
+
+  class CommandFailed < StandardError; end
+
+end

data/lib/mason/buildpack.rb

@@ -0,0 +1,64 @@
+require "mason"
+require "tmpdir"
+
+class Mason::Buildpack
+
+  attr_reader :dir, :name, :url
+
+  def initialize(dir)
+    @dir = dir
+    Dir.chdir(@dir) do
+      @name = File.basename(@dir)
+      @url  = %x{ git config remote.origin.url }.chomp
+    end
+  end
+
+  def <=>(other)
+    self.name <=> other.name
+  end
+
+  def detect(app)
+    mkchtmpdir do
+      output = %x{ #{script("detect")} "#{app}" }
+      $?.exitstatus.zero? ? output.chomp : nil
+    end
+  end
+
+  def compile(app)
+    mkchtmpdir do |cache_dir|
+      compile_dir = Dir.mktmpdir
+      FileUtils.rm_rf compile_dir
+      FileUtils.cp_r app, compile_dir
+      Dir.chdir(compile_dir) do
+        IO.popen(%{ #{script("compile")} "#{compile_dir}" "#{cache_dir}" }) do |io|
+          until io.eof?
+            data = io.gets
+            data.gsub!(/^-----> /, "  + ")
+            data.gsub!(/^       /, "      ")
+            data.gsub!(/^\s+$/, "")
+            print data
+          end
+        end
+      end
+      compile_dir
+    end
+  end
+
+private
+
+  def mkchtmpdir
+    ret = nil
+    Dir.mktmpdir do |dir|
+      Dir.chdir(dir) do
+        ret = yield(dir)
+      end
+    end
+    ret
+  end
+
+  def script(name)
+    File.join(dir, "bin", name)
+  end
+
+end
+

data/lib/mason/buildpacks.rb

@@ -0,0 +1,51 @@
+require "fileutils"
+require "mason"
+require "mason/buildpack"
+require "uri"
+
+class Mason::Buildpacks
+
+  def self.install(url)
+    FileUtils.mkdir_p root
+
+    Dir.chdir(root) do
+      if URI.parse(url).path =~ /buildpack-(\w+)/
+        name = $1
+        raise "#{name} buildpack already installed" if File.exists?(name)
+        system "git clone #{url} #{name} >/dev/null 2>&1"
+        raise "failed to clone buildpack" unless $?.exitstatus.zero?
+      else
+        raise "BUILDPACK should be a url containing buildpack-NAME.git"
+      end
+    end
+  end
+
+  def self.uninstall(name)
+    Dir.chdir(root) do
+      raise "#{name} buildpack is not installed" unless File.exists?(name)
+      FileUtils.rm_rf name
+    end
+  end
+
+  def self.root(expand=true)
+    dir = "~/.mason/buildpacks"
+    expand ? File.expand_path(dir) : dir
+  end
+
+  def self.buildpacks
+    @buildpacks ||= begin
+      Dir[File.join(root, "*")].map do |buildpack_dir|
+        Mason::Buildpack.new(buildpack_dir)
+      end
+    end
+  end
+
+  def self.detect(app)
+    buildpacks.each do |buildpack|
+      ret = buildpack.detect(app)
+      return [buildpack, ret] if ret
+    end
+    nil
+  end
+
+end

data/lib/mason/cli.rb

@@ -0,0 +1,256 @@
+require "mason"
+require "mason/buildpacks"
+require "mason/stacks"
+require "mason/version"
+require "thor"
+require "thor/shell/basic"
+
+class Mason::CLI < Thor
+
+  class_option :help, :type => :boolean, :aliases => "-h", :desc => "help for this command"
+
+  map %w( -v -V --version ) => :version
+
+  desc "version", "display version"
+
+  def version
+    puts "mason v#{Mason::VERSION}"
+  end
+
+  desc "build APP", "build an app"
+
+  method_option :buildpack, :type => :string, :aliases => "-b", :desc => "use a custom buildpack"
+  method_option :output,    :type => :string, :aliases => "-o", :desc => "output location"
+  method_option :quiet,     :type => :boolean, :aliases => "-q", :desc => "quiet packaging output"
+  method_option :stack,     :type => :string, :aliases => "-s", :desc => "use a stack for building"
+  method_option :type,      :type => :string, :aliases => "-t", :desc => "output type (dir, img, tgz)"
+
+  def build(app)
+    raise "no such directory: #{app}" unless File.exists?(app)
+
+    type = options[:type]
+    output = options[:output]
+
+    type = File.extname(output)[1..-1] if !type && output
+    output = "#{app}.#{type}" if !output && type
+    type ||= "dir"
+
+    raise "no such output format: #{type}" unless %w( dir img tgz ).include?(type)
+
+    if stack = options[:stack]
+      print "* booting stack #{stack} (this may take a while)... "
+      Mason::Stacks.up(stack)
+      puts "done"
+
+      buildpacks_dir = File.expand_path("~/.mason/share/#{stack}/buildpacks")
+      compile_dir = File.expand_path("~/.mason/share/#{stack}/app")
+      mason_dir = File.expand_path("~/.mason/share/#{stack}/mason")
+
+      FileUtils.rm_rf buildpacks_dir
+      FileUtils.rm_rf compile_dir
+      FileUtils.rm_rf mason_dir
+
+      FileUtils.cp_r File.expand_path("~/.mason/buildpacks"), buildpacks_dir
+      FileUtils.cp_r app, compile_dir
+      FileUtils.cp_r File.expand_path("../../../", __FILE__), mason_dir
+
+      mason_args =  %{ /share/app -q -o /share/output -t #{type} }
+      mason_args += %{ -b "#{options[:buildpack]}" } if options[:buildpack]
+
+      Mason::Stacks.run(stack, <<-COMMAND)
+        gem spec thor 2>&1 >/dev/null || sudo gem install thor
+        /usr/bin/env ruby -rubygems /share/mason/bin/mason build #{mason_args}
+      COMMAND
+
+      FileUtils.cp_r File.expand_path("~/.mason/share/#{stack}/output"), output
+
+      puts "* packaging"
+      puts "  = type: #{type}"
+      puts "  = location: #{output}"
+    else
+      print "* detecting buildpack... "
+
+      buildpack, ret = Mason::Buildpacks.detect(app)
+      raise "no valid buildpack detected" unless buildpack
+
+      puts "done"
+      puts "  = name: #{buildpack.name}"
+      puts "  = url: #{buildpack.url}"
+      puts "  = display: #{ret}"
+
+      puts "* compiling..."
+      compile_dir = buildpack.compile(app)
+
+      print "* packaging... " unless options[:quiet]
+      case type.to_sym
+      when :tgz then
+        Dir.chdir(compile_dir) do
+          system %{ tar czf "#{output}" . }
+        end
+      when :img then
+        puts "not yet"
+      when :dir then
+        FileUtils.rm_rf output
+        FileUtils.cp_r compile_dir, output
+      else
+        raise "no such output type: #{type}"
+      end
+
+      unless options[:quiet]
+        puts "done"
+        puts "  = type: #{type}"
+        puts "  = location: #{output}"
+      end
+    end
+
+  end
+
+  desc "vagrant COMMAND", "run a vagrant command in the mason environment"
+
+  def vagrant(*args)
+    Mason::Stacks.vagrant(args)
+  end
+
+  desc "buildpacks", "list installed buildpacks"
+
+  def buildpacks
+    buildpacks = Mason::Buildpacks.buildpacks
+
+    puts "* buildpacks (#{Mason::Buildpacks.root(false)})"
+    buildpacks.sort.each do |buildpack|
+      puts "  = #{buildpack.name}: #{buildpack.url}"
+    end
+
+    puts "  - no buildpacks installed, use buildpacks:add" if buildpacks.length.zero?
+  end
+
+  class Buildpacks < Thor
+
+    desc "buildpacks:install URL", "install a buildpack"
+
+    def install(url)
+      puts "* adding buildpack #{url}"
+      Mason::Buildpacks.install url
+    end
+
+    desc "buildpacks:uninstall NAME", "uninstall a buildpack"
+
+    def uninstall(name)
+      puts "* removing buildpack #{name}"
+      Mason::Buildpacks.uninstall name
+    end
+
+  end
+
+  desc "stacks", "list available stacks"
+
+  def stacks
+    puts "* available stacks"
+    Mason::Stacks.vms.each do |name, vm|
+      next if name == :default
+      puts "  - #{name} [#{Mason::Stacks.state(name)}]"
+    end
+  end
+
+  class Stacks < Thor
+
+    # Hackery. Take the run method away from Thor so that we can redefine it.
+    class << self
+      def is_thor_reserved_word?(word, type)
+        return false if word == 'run'
+        super
+      end
+    end
+
+    desc "stacks:create name", "create a new stack"
+
+    method_option :box, :type => :string, :aliases => "-b", :desc => "vagrant box name"
+
+    def create(name)
+      box = options[:box] || name
+      print "* creating stack #{name}... "
+      Mason::Stacks.create(name, box)
+      puts "done"
+    end
+
+    desc "stacks:destroy STACK", "destroy a stack"
+
+    def destroy(name)
+      print "* destroying stack #{name}... "
+      Mason::Stacks.destroy(name)
+      puts "done"
+    end
+
+    desc "stacks:up STACK", "boot a stack"
+
+    def up(name)
+      print "* booting stack #{name} (this will take a while)..."
+      Mason::Stacks.up(name)
+      puts "done"
+    end
+
+    desc "stacks:down STACK", "boot a stack"
+
+    def down(name)
+      print "* stopping stack #{name}..."
+      Mason::Stacks.down(name)
+      puts "done"
+    end
+
+    desc "stacks:run STACK COMMAND", "run a command on a stack"
+
+    def run(name, *args)
+      Mason::Stacks.run(name, args.join(" "))
+    end
+
+  end
+
+  # hack thor
+  def self.run
+    args   = ARGV.dup
+    parts  = args.first.to_s.split(":")
+    method = parts.pop
+    ns     = parts.pop
+
+    args[0] = method
+
+    klass = case ns
+      when "buildpacks" then Buildpacks
+      when "stacks"     then Stacks
+      else self
+    end
+
+    unless (args & %w( -h --help )).empty?
+      klass.task_help(Thor::Shell::Basic.new, args.first)
+      return
+    end
+
+    klass.start(args)
+  # rescue StandardError => ex
+  #   raise Mason::CommandFailed, ex.message
+  end
+
+private
+
+  def vagrantfile
+    FileUtils.mkdir_p File.expand_path("~/.mason")
+    file = File.expand_path("~/.mason/Vagrantfile")
+    build_vagrantfile unless File.exists?(file)
+    file
+  end
+
+  def build_vagrantfile(boxes={})
+    data = File.read(File.expand_path("../../../data/Vagrantfile.template", __FILE__))
+    data.gsub! "BOXES", (boxes.map do |name, box|
+      <<-BOX
+        config.vm.define :#{name} do |config|
+          config.vm.box = "#{box}"
+        end
+      BOX
+    end.join("\n"))
+    File.open(File.expand_path("~/.mason/Vagrantfile"), "w") do |file|
+      file.puts data
+    end
+  end
+
+end

data/lib/mason/stacks.rb

@@ -0,0 +1,110 @@
+require "fileutils"
+require "mason"
+
+class Mason::Stacks
+
+  def self.load_vagrant!
+    require "vagrant"
+    build_vagrantfile unless File.exists?(vagrantfile)
+  end
+
+  def self.vagrant_env(display=false)
+    ui = display ? Vagrant::UI::Basic : nil
+    Vagrant::Environment.new(:vagrantfile_name => vagrantfile, :ui_class => ui)
+  end
+
+  def self.vms
+    load_vagrant!
+    vagrant_env.vms
+  end
+
+  def self.vagrant(args)
+    vagrant_env(true).cli(args)
+  end
+
+  def self.stacks
+    @stacks ||= begin
+      vms.inject({}) do |hash, (name, vm)|
+        next(hash) if name == :default
+        hash.update(name => vm.box ? vm.box.name : "")
+      end
+    end
+  end
+
+  def self.create(name, box)
+    raise "stack already exists: #{name}" if stacks.keys.include?(name.to_sym)
+    raise "vagrant box does not exist: #{box}" unless vagrant_env.boxes.map(&:name).include?(box)
+    build_vagrantfile(stacks.update(name => box))
+  end
+
+  def self.destroy(name)
+    raise "no such stack: #{name}" unless stacks.keys.include?(name.to_sym)
+    vm = vms[name.to_sym]
+    vm.halt rescue Vagrant::Errors::VBoxManagerError
+    vm.destroy rescue Vagrant::Errors::VBoxManageError
+    s = stacks
+    s.delete(name.to_sym)
+    build_vagrantfile(s)
+  end
+
+  def self.state(name)
+    raise "no such stack: #{name}" unless stacks.keys.include?(name.to_sym)
+    case vms[name.to_sym].state.to_sym
+      when :running then :up
+      else               :down
+    end
+  end
+
+  def self.up(name)
+    raise "no such stack: #{name}" unless stacks.keys.include?(name.to_sym)
+    return if state(name) == :up
+    vms[name.to_sym].up
+  end
+
+  def self.down(name)
+    raise "no such stack: #{name}" unless stacks.keys.include?(name.to_sym)
+    return if state(name) == :down
+    vms[name.to_sym].suspend
+  end
+
+  def self.run(name, command)
+    raise "no suck stack: #{name}" unless stacks.keys.include?(name.to_sym)
+    vms[name.to_sym].channel.execute(command, :error_check => false) do |type, data|
+      print data
+    end
+  end
+
+  def self.vagrantfile
+    File.expand_path("~/.mason/Vagrantfile")
+  end
+
+  def self.vagrantfile_template
+    File.expand_path("../../../data/Vagrantfile.template", __FILE__)
+  end
+
+  def self.share_dir(name)
+    dir = File.expand_path("~/.mason/share/#{name}")
+    FileUtils.mkdir_p dir unless File.exists?(dir)
+    dir
+  end
+
+  def self.build_vagrantfile(stacks={})
+    data = File.read(vagrantfile_template)
+    ip_base = 3
+    data.gsub! "BOXES", (stacks.map do |name, box|
+      ip_base += 1
+      <<-BOX
+  config.vm.define :#{name} do |config|
+    config.vm.box = "#{box}"
+    config.vm.base_mac = "080027706AA#{ip_base}"
+    config.vm.network :hostonly, "33.33.33.#{ip_base}"
+    config.vm.share_folder "share", "/share", "#{share_dir(name)}"
+  end
+      BOX
+    end.join("\n").chomp)
+    File.open(vagrantfile, "w") do |file|
+      file.puts data
+    end
+  end
+
+end

data/lib/mason/version.rb

@@ -0,0 +1,3 @@
+module Mason
+  VERSION = "0.0.1"
+end

metadata

@@ -0,0 +1,65 @@
+--- !ruby/object:Gem::Specification
+name: mason
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- David Dollar
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-03-18 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: thor
+  requirement: &70148573564580 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70148573564580
+description: Build things
+email: ddollar@gmail.com
+executables:
+- mason
+extensions: []
+extra_rdoc_files: []
+files:
+- bin/mason
+- data/Vagrantfile.template
+- lib/mason/buildpack.rb
+- lib/mason/buildpacks.rb
+- lib/mason/cli.rb
+- lib/mason/stacks.rb
+- lib/mason/version.rb
+- lib/mason.rb
+- README.md
+homepage: http://github.com/ddollar/mason
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.11
+signing_key: 
+specification_version: 3
+summary: Build things
+test_files: []