shuttl 0.3.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: cdced374d119718cdd22b9d9886632a5eda06260
+  data.tar.gz: 621609539b377b2f2f78f8839089a136de80bd6c
+SHA512:
+  metadata.gz: 8073a8497ab099c178a28bf200264e79c12f01483727da95fe89442048a98ce4736b1ef5b2a36ef8574b68dd587b057247982f72d0a37449c974489556636a43
+  data.tar.gz: 95d6d4e9a61d177012f7ce0e68f612b0db3ab4fe152ee5caa5ed278d20be32d774003d7e9e9b95fe2e474f8297534648fd50bafca870b03fb674a1c74966e1a9

data/bin/shuttl

@@ -0,0 +1,140 @@
+#!/usr/bin/ruby
+
+require 'optparse'
+require 'colorize'
+require_relative '../src/dsl/eval'
+require_relative '../src/commands/start'
+require_relative '../src/commands/stop'
+require_relative '../src/commands/build'
+require_relative '../src/commands/info'
+require_relative '../src/commands/run'
+require_relative '../src/commands/ssh'
+require_relative '../src/commands/deploy'
+require_relative '../src/commands/install'
+require_relative '../src/settings'
+
+Docker.validate_version!
+
+VERSION = "#{ShuttlSettings::VERSION} build #{ShuttlSettings::BUILD}"
+
+options = {
+    :fileName => './Shuttlfile'
+}
+
+globals = OptionParser.new do |opts|
+    opts.banner = "Usage: shuttl [command]"
+end
+
+subcommands = Hash[
+    "start" => {
+        :opts => OptionParser.new do |opts| 
+            opts.banner = "Starts a new instance of the app"
+            opts.on('--file FILE', 'Defines the file to use as the build file') do |file|
+                options[:fileName] = file
+            end
+            options[:stage] = 'dev'
+        end,
+        :runner => Start.new
+    },
+    'build' => { 
+        :opts => OptionParser.new do |opts|
+            options[:stage] = 'dev'
+            options[:clean] = false
+            options[:env] = nil
+            opts.on('--file FILE', 'Defines the file to use as the build file') do |file|
+                options[:fileName] = file
+            end       
+            opts.on('-s STAGE', '--stage STAGE', 'The build stage') do |stage|
+                options[:stage] = stage
+            end
+            opts.on('--clean', 'Preform a clean build (Don\'t use the cache)') do 
+                options[:clean] = true
+            end
+            opts.on('--env FILE', 'defines the build arguments to use') do |file|
+                options[:env] = file
+            end
+        end,
+        :runner => Build.new
+    },
+    'show' => {
+        :opts => OptionParser.new do |opts|
+            options[:stage] = 'dev'
+            options[:showIP] = false
+            options[:showDocker] = false
+            options[:container] = false
+            options[:status] = false
+            opts.on('--docker-file', 'Show the docker file') do |file|
+                options[:showDocker] = true
+            end  
+            opts.on('--file FILE', 'Defines the file to use as the build file') do |file|
+                options[:fileName] = file
+            end       
+            opts.on('-s STAGE', '--stage STAGE', 'The build stage') do |stage|
+                options[:stage] = stage
+            end
+            opts.on('--ip', 'Shows the IP address of the running container') do
+                options[:showIP] = true
+            end
+            opts.on('--container', 'Shows the container\'s json information') do
+                options[:container] = true
+            end
+            opts.on('--status', 'Shows the container\'s status') do
+                options[:status] = true
+            end
+        end,
+        :runner => Info.new
+    },
+    'stop' => {
+        :opts => OptionParser.new do |opts|
+            options[:stage] = 'dev'
+        end,
+        :runner => Stop.new
+    },
+    'run' => {
+        :opts => OptionParser.new do |opts|
+        end,
+        :runner => Run.new
+    },
+    'ssh' => {
+        :opts => OptionParser.new do |opts|
+        end,
+        :runner => SSH.new
+    },
+    'deploy' => {
+        :opts => OptionParser.new do |opts|
+            options[:stage] = 'production'
+            opts.on('-s STAGE', '--stage STAGE', 'The build stage') do |stage|
+                options[:stage] = stage
+            end
+            opts.on('-t TAG', '--registry TAG', 'The registry to push to') do |tag|
+                options[:tag] = tag
+            end
+        end,
+        :runner => Deploy.new
+    },
+    'install' => {
+        :opts => OptionParser.new do |opts|
+            options[:installPath] = "#{Dir.home}/.shuttl"
+            opts.on('-p PATH', '--install-path PATH', 'The path to install to') do |path| 
+                options[:installPath] = path
+            end
+        end,
+        :runner => Install.new
+    }
+]
+
+global = OptionParser.new do |opts|
+    opts.banner = "Usage: shuttl [options] [subcommand [options]]"
+    opts.on('--version', 'get the version of the app') do
+        options[:skip_all] = true
+        puts "Shuttl Version: #{VERSION}".green
+    end
+    # ...
+end
+
+global.order!
+if !options[:skip_all]
+    command = ARGV.shift
+    subcommands[command][:opts].order!
+    subcommands[command][:runner].handle options, ARGV
+end

data/src/Shuttl/Loader.rb

@@ -0,0 +1,39 @@
+
+class Loader
+    # require '../dsl/eval'    
+    def initialize ()
+        @dirs = []
+        shuttlDir = File.join(Dir.home, '.shuttl/definitions')
+        @dirs << shuttlDir
+        if ENV.key('SHUTTL_PATH')
+            @dirs << ENV['SHUTTL_PATH'].split(":")
+        end
+        @dirs << Dir.getwd
+    end
+
+    def find (name, stage)
+        found = nil
+        [name, "#{name}.shuttlfile"].each do |fileName|
+            found = findFile(fileName, stage)
+            if !found.nil?
+                break
+            end
+        end
+        if found.nil?
+            throw "No shuttl file found"
+        end
+        found
+    end
+
+    def findFile (file, stage)
+        found = nil
+        @dirs.each do | dir |
+            potentialFileName = File.join(dir, file)
+            if File.exist? potentialFileName
+                found = ShuttlDSL.load potentialFileName, stage
+                break
+            end
+        end
+        found
+    end
+end

data/src/Shuttl/Shuttl.rb

@@ -0,0 +1,9 @@
+# class ShuttlCommand 
+#     def initialize
+       
+#     end
+
+#     def merge (context)
+#         context.docker.concat @docker
+#     end
+# end

data/src/commands/base.rb

@@ -0,0 +1,48 @@
+require 'json'
+
+class CommandBase
+    def initialize
+        @fileLocation = File.join(Dir.home, '.shuttl')
+        File.open(File.join(@fileLocation, 'info'), 'r') do |fi|
+            @info = JSON.parse(fi.read)
+        end
+        @cwd = Dir.getwd
+    end
+
+    def handle (options, args)
+        @args = args
+        self.run options
+        self.cleanUp options
+    end
+
+    def run (options)
+    end
+
+    def cleanUp (options)
+        File.open(File.join(Dir.home, '.shuttl/info'), 'w') do |fi|
+            fi.write @info.to_json
+        end
+    end
+
+    def hasImage?
+        hasImage = @info['images'].key?(@cwd)
+        if hasImage
+            @current_image_info = @info['images'][@cwd]            
+            @image = Docker::Image.get(@info['images'][@cwd]["image_id"])
+        end
+        hasImage
+    end
+
+    def isRunning?
+        if (@info['containers'].key?(@cwd))
+            begin
+                @container = Docker::Container.get(@info['containers'][@cwd]["container_id"])
+            rescue Docker::Error::NotFoundError
+                @info['containers'].delete(@cwd)
+                return false
+            end
+            return @container.json['State']['Running']
+        end
+        false
+    end
+end

data/src/commands/build.rb

@@ -0,0 +1,39 @@
+require 'docker'
+require 'json'
+
+require_relative '../dsl/eval'
+require_relative 'base'
+
+class Build < CommandBase
+
+    def build (options)
+        Docker.options[:read_timeout] = 180
+        $stdout.print "Building new image\n"        
+        file = File.expand_path(options[:fileName], Dir.getwd)
+        shuttlConfig = ShuttlDSL.load file, options[:stage]
+        shuttlConfig.setEnvFile options[:env]
+        # tar = shuttlConfig.makeImage options[:stage], @cwd
+        begin
+            step = 1
+            @image = shuttlConfig.build options[:stage], @cwd, options[:clean] do |v|
+                if (log = JSON.parse(v)) && log.has_key?("stream")
+                    $stdout.puts log['stream']
+                    if log['stream'].include? 'Step'
+                        step += 1
+                    end
+                end
+            end
+            if !shuttlConfig.getName().nil?
+                @image.tag('repo' => shuttlConfig.getName())
+            end
+            @info['images'][@cwd] = {:image_id => @image.id, :volumes => shuttlConfig.gatherVolume(options[:stage]), :built => Time.now.to_i, :stage => options[:stage]}
+        rescue Docker::Error::UnexpectedResponseError => error
+            $stderr.puts "Build Failed!".red
+        end
+    end
+
+    def run (options)
+        self.build options
+    end
+
+end

data/src/commands/deploy.rb

@@ -0,0 +1,46 @@
+require 'docker'
+require 'json'
+require 'colorize'
+
+require_relative '../dsl/eval'
+require_relative 'base'
+
+class Deploy < CommandBase
+
+    def build (options)
+        $stdout.print "Building new image\n"        
+        file = File.expand_path(options[:fileName], Dir.getwd)
+        shuttlConfig = ShuttlDSL.load file, options[:stage]
+        # tar = shuttlConfig.makeImage options[:stage], @cwd
+        begin
+            step = 1
+            @image = shuttlConfig.build options[:stage], @cwd, true do |v|
+                if (log = JSON.parse(v)) && log.has_key?("stream")
+                    $stdout.puts log['stream']
+                    if log['stream'].include? 'Step'
+                        step += 1
+                    end
+                end
+            end
+            if !shuttlConfig.getName().nil?
+                @image.tag('repo' => shuttlConfig.getName())
+            end
+            @info['images'][@cwd] = {:image_id => @image.id, :volumes => shuttlConfig.gatherVolume(options[:stage]), :built => Time.now.to_i, :stage => options[:stage]}
+        rescue Docker::Error::UnexpectedResponseError => error
+            $stderr.puts "Build Failed!".red
+        end
+    end
+
+    def run (options)
+        Docker.authenticate!
+        self.build options
+        `$(aws ecr get-login --no-include-email --region us-east-2)`
+        @image.tag('repo' => 'shuttl/django', 'tag' => options[:stage])
+        @image.tag('repo' => options[:tag], 'tag' => 'latest', force: true)
+        @image.push(nil, repo_tag: "#{options[:tag]}") do |stream, chunk|
+            $stdout.puts "#{stream}: #{chunk}"
+        end
+        $stdout.puts "Deploy done!".green
+    end
+
+end

data/src/commands/info.rb

@@ -0,0 +1,50 @@
+require 'docker'
+require 'colorize'
+require 'json'
+
+require_relative '../dsl/eval'
+require_relative 'base'
+
+class Info < CommandBase
+
+    def build (options)
+        file = File.expand_path(options[:fileName], Dir.getwd)
+        shuttlConfig = ShuttlDSL.load file, options[:stage]
+        # tar = shuttlConfig.makeImage options[:stage], @cwd
+        $stdout.puts shuttlConfig.makeDockerFile options[:stage]
+    end
+
+    def run (options)
+        if options[:showDocker]
+            self.build options
+        end
+        if options[:showIP]
+            if isRunning?
+                $stdout.puts "IP Address: #{@info['containers'][@cwd]["json"]['NetworkSettings']['IPAddress']}".green
+            else
+                $stderr.puts "No container running for this dir!".red
+            end
+        end
+        if options[:container]
+            if isRunning?
+                puts JSON.pretty_generate(@container.json)
+            else
+                $stderr.puts "No container running for this dir!".red
+            end
+        end
+        if options[:status]
+            if isRunning?
+                if @container.json["State"]['Running']
+                    $stdout.puts "Shuttl is up and running!".green
+                else
+                    @container.json["State"].each do |name, value|
+                        puts "#{name}: #{value}" 
+                    end
+                end
+            else
+                $stderr.puts "No container running for this dir!".red
+            end
+        end
+    end
+
+end

data/src/commands/install.rb

@@ -0,0 +1,38 @@
+require 'docker'
+require 'json'
+require 'colorize'
+require 'net/http'
+require 'zip'
+
+require_relative '../dsl/eval'
+require_relative 'base'
+
+class Install < CommandBase
+
+    def run (options)
+        tempFile = Tempfile.new('shuttl.zip')        
+        Net::HTTP.start("s3.us-east-2.amazonaws.com") do |http|
+            resp = http.get("/shuttl-cli/shuttlinfo.zip")
+            tempFile.write(resp.body)
+        end
+        tempFile.close
+        Zip::File.open(tempFile.path) do |zip_file|
+            # Handle entries one by one
+            zip_file.each do |entry|
+              # Extract to file/directory/symlink
+              entry.extract(File.join(options[:installPath], entry.name.gsub('.shuttl/', ''))) {true}
+            end
+        end
+        tempFile.unlink
+
+        base = {
+            :images => {},
+            :containers => {},
+        }
+
+        File.open(File.join(Dir.home, '.shuttl/info'), 'w') do |fi|
+            fi.write base.to_json
+        end
+    end
+
+end

data/src/commands/run.rb

@@ -0,0 +1,21 @@
+require 'docker'
+require 'colorize'
+
+require_relative 'base'
+
+class Run < CommandBase
+    
+    def run (options)
+        if !isRunning?
+            $stdout.puts "Shuttl not running! run shuttl start".red
+            return
+        end
+        fd = IO.sysopen "/dev/tty", "w"
+        ios = IO.new(fd, "w")
+        output = @container.exec(@args, tty: true) do |stream| 
+            ios.print stream
+        end
+        ios.close
+    end
+
+end

data/src/commands/ssh.rb

@@ -0,0 +1,29 @@
+require 'docker'
+require 'colorize'
+
+require_relative 'base'
+
+class SSH < CommandBase
+    
+    def run (options)
+        if !isRunning?
+            $stderr.puts "Shuttl not running! run shuttl start".red
+            return
+        end
+        fd = IO.sysopen "/dev/tty", "w"
+        ios = IO.new(fd, "w")
+        ios.raw!
+        begin
+            @container.exec(['/bin/bash'], stdin: $stdin, tty: true, stdout: true, stderr: true, stream: true) do |stream|
+                ios.print stream
+            end
+        rescue Interrupt => e
+        rescue Exception => e
+            $stderr.puts "Error: #{e}".red
+        end
+        ios.close
+        ## The space is put before the command so that it won't show up in bash history
+        ` stty sane`
+    end
+
+end

data/src/commands/start.rb

@@ -0,0 +1,77 @@
+require 'docker'
+require 'colorize'
+
+require_relative '../dsl/eval'
+require_relative 'base'
+
+class Booted < StandardError
+end
+
+class Start < CommandBase
+    
+    def build (options)
+        $stdout.print "Building new image\n"        
+        file = File.expand_path(options[:fileName], Dir.getwd)
+        shuttlConfig = ShuttlDSL.load file, options[:stage]
+        begin
+            step = 1
+            @image = shuttlConfig.build options[:stage], @cwd do |v|
+                if (log = JSON.parse(v)) && log.has_key?("stream")
+                    $stdout.puts log['stream']
+                    if log['stream'].include? 'Step'
+                        step += 1
+                    end
+                end
+            end
+            if !shuttlConfig.getName().nil?
+                @image.tag('repo' => shuttlConfig.getName())
+            end
+            @info['images'][@cwd] = {:image_id => @image.id, :volumes => shuttlConfig.gatherVolume(options[:stage]), :built => Time.now.to_i}
+        rescue Docker::Error::UnexpectedResponseError => error
+            $stderr.puts error
+        end
+    end
+    
+    def startContainer (options)
+        $stdout.puts "Starting image"
+        @container = Docker::Container.create(
+            'Image' => @image.id,
+            'HostConfig' => {
+                "Binds" => @current_image_info['volumes'].map {|mountPoint, hostDir| "#{hostDir}:#{mountPoint}"}
+            }
+        ).start
+        begin
+            catch (Booted) do 
+                @container.tap(&:start).attach do |stream, chunk| 
+                    if chunk.include? 'SHUTTL IMAGE BOOTED'
+                        throw Booted
+                    end
+                    $stdout.puts "#{stream}: #{chunk}" 
+                end
+            end
+            $stdout.puts "Container is fully booted and ready for use!".green
+            $stdout.puts "Container's id is #{@container.id} and the IP is: #{@container.json['NetworkSettings']['IPAddress']}".green      
+        rescue Exception => e
+            $std.puts  "error: #{e}"
+        end
+        @info['containers'][@cwd] = {:container_id => @container.id, :status => 'running', :json => @container.json }
+    end
+
+    def shouldRebuild?(mtime)
+        @current_image_info["built"] < mtime.to_i
+    end
+
+
+    def run (options)
+        if self.isRunning?
+            $stdout.puts "Already running!"
+            return
+        end
+        if self.hasImage? && !shouldRebuild?(File.mtime(File.expand_path(options[:fileName], Dir.getwd)))
+            return self.startContainer options
+        end
+        self.build options
+        self.startContainer options
+    end
+
+end

data/src/commands/stop.rb

@@ -0,0 +1,18 @@
+require 'docker'
+
+require_relative '../dsl/eval'
+require_relative 'base'
+
+class Stop < CommandBase
+    
+    def run (options)
+        if self.isRunning?
+            $stdout.puts "Stopping Shuttl instance"
+            @container.kill
+        else
+            $stdout.puts "Not running?"
+        end
+            
+    end
+
+end

data/src/dsl/Shuttl.rb

@@ -0,0 +1,100 @@
+## Base class for the DSL definition
+require 'uri'
+require 'docker'
+
+class Shuttl
+
+    attr_accessor :name, :stage
+
+    def initialize (builder)
+        @builder = builder
+    end
+
+    def DEFINES (name)
+        @builder.setName(name)
+    end
+
+    def add (command)
+        @builder.add command
+    end
+
+    def fileAdd (source)
+        @builder.fileAdd source
+    end 
+
+    def FROM (name)
+        self.add "FROM #{name}"
+    end
+
+    def RUN (name)
+        self.add "RUN #{name}"
+    end
+
+    def ADD (source, destination)
+        if source !=~ /\A#{URI::regexp}\z/
+            @builder.fileAdd(source, destination)
+        else
+            self.add "ADD #{source} #{destination}"
+        end
+    end
+
+    def COPY(source, destination)
+        self.add "COPY #{source} #{destination}"
+    end
+
+    def EXPOSE (port)
+        self.add "EXPOSE #{port}"
+    end
+
+    def ENTRYPOINT (entrypoint)
+        @builder.entrypoint = entrypoint
+    end
+
+    def ONSTART (cmd)
+        self.add "RUN echo \"#{cmd}\" >> /.shuttl/run" 
+    end
+
+    def ONRUN (cmd)
+        self.add "RUN echo \"#{cmd}\" >> /.shuttl/start"
+    end
+
+    def EXTENDS (name)
+        require_relative '../Shuttl/Loader'
+        loader = Loader.new
+        @builder.merge loader.find name, @builder.buildStage
+    end
+
+    def USE (name)
+        EXTENDS name
+    end
+
+    def SET (setting, value)
+        @builder.set setting, value
+    end
+
+    def ON (name)
+        @builder.on name do
+            yield
+        end
+    end
+
+    def VOLUME (volume)
+        self.add "VOLUME #{volume}"
+    end
+
+    def ATTACH (localDir, volume)
+        @builder.attach(localDir, volume)
+    end
+
+    def ENVIRONMENT (tester)
+        tester.call(@builder.buildSettings[:settings]['ENVIRONMENT'])
+    end
+
+    def IS (name)
+        proc {|value| value == name }
+    end
+
+    def CMD (cmd)
+        @builder.cmd cmd
+    end
+end

data/src/dsl/buildContext.rb

@@ -0,0 +1,209 @@
+class Builder 
+
+    attr_accessor :stage, :buildStage, :buildSettings, :volumes, :entrypoint
+    def initialize (fileLocation, stage=nil, name=nil)
+        @name = name
+        @buildStage = stage
+        @buildSettings = { :settings => {}, :docker => [], :files => {}, :volumes => {} }
+        @entrypoint = nil
+        @volumes = {}
+        @cwd = Dir.getwd
+        @fileLocation = fileLocation
+        @output = Tempfile.new('shuttlBuild')
+        @tar = Gem::Package::TarWriter.new(@output)
+        @dirs = [fileLocation, Dir.getwd, File.join(Dir.home, '.shuttl/definitions')]
+        if ENV.key('SHUTTL_PATH')
+            @dirs << ENV['SHUTTL_PATH'].split(":")
+        end
+    end
+
+    def findFile(name)
+        found = nil
+        @dirs.each do | dir |
+            potentialFileName = File.join(dir, name)
+            if File.exist? potentialFileName
+                if File.directory? potentialFileName
+                    raise Errno::EISDIR
+                end
+                found = File.open(potentialFileName)
+                break
+            end
+        end
+        if found.nil?
+            throw "File not found: #{name}"
+        end
+        found
+    end
+
+    def setName(name)
+        @name = name
+    end
+
+    def getName        
+        @name
+    end
+
+    def addFile(localName, nameInDocker, rootName=nil)
+        if rootName.nil?
+            rootName = nameInDocker
+        end
+        begin
+            file = findFile(localName)
+        rescue Errno::EISDIR
+            @tar.mkdir(nameInDocker, 0640)
+            Dir["#{localName}/**/*"].each do |file|
+                pathInDocker = File.join(rootName, file)
+                addFile(file, pathInDocker, rootName)
+            end
+            return
+        end
+
+        permissions = file.is_a?(Hash) ? file[:permissions] : 0640
+        @tar.add_file(nameInDocker, permissions) do | tarFile | 
+            while buffer = file.read(1024 * 1000)
+                tarFile.write(buffer)
+            end
+        end
+        @tar.flush
+    end
+
+    def create_tar(hash = {}, tap=true)
+        output = StringIO.new
+        Gem::Package::TarWriter.new(output) do |tar|
+            hash.each do |file_name, file_details|
+                permissions = file_details.is_a?(Hash) ? file_details[:permissions] : 0640
+                tar.add_file(file_name, permissions) do |tar_file|
+                    content = file_details.is_a?(Hash) ? file_details[:content] : file_details
+                    tar_file.write(content)
+                end
+            end
+        end
+        return output.tap(&:rewind)
+    end
+
+    def gatherSettings (stage)
+        settings = @buildSettings[:settings]
+    end
+
+    def makeDockerFile (stage)
+        settings = gatherSettings(stage)
+        settingsArr = []
+        settings.each do |key, value|
+            settingsArr << "ARG #{key}=#{value}"
+            settingsArr << "ENV #{key}=${#{key}}"
+        end
+        definition = @buildSettings[:docker]
+        definition = [definition[0], ] + settingsArr + definition[1..definition.count]
+        if @entrypoint
+            definition << "ENTRYPOINT #{@entrypoint}"
+        end
+        volumes = gatherVolume stage
+        definition << "RUN echo 'echo SHUTTL IMAGE BOOTED' >> /.shuttl/run"
+        definition << "RUN echo 'bash /.shuttl/start' >> /.shuttl/run"
+        if volumes.keys.count > 0
+            definition << "VOLUME #{volumes.keys}"
+        end
+        definition.join("\n") 
+    end
+
+
+    def gatherFiles (stage, cwd)
+        files = @buildSettings[:files]
+        files
+    end
+
+    def makeImage (stage, cwd)
+        dockerfile = self.makeDockerFile stage
+        files = self.gatherFiles stage, cwd
+        @tar.add_file("Dockerfile", 0640) do |tar_file|
+            tar_file.write(dockerfile)
+        end
+        files.each do |key, val|
+            addFile(key, val)
+        end
+    end
+
+    def build (stage, cwd, clean )
+        begin
+            makeImage stage, cwd
+            query = {}
+            query[:buildargs] = {}
+            @buildSettings[:settings].each do |key, value|
+                query[:buildargs][key] = value.to_s
+            end
+            query[:buildargs] = query[:buildargs].merge @env || Hash[]
+            puts query[:buildargs]
+            query[:buildargs] = query[:buildargs].to_json
+            if clean
+                query[:nocache] = true
+            end
+            puts query
+            Docker::Image.build_from_tar @output.tap(&:rewind), query do |v|
+                yield v
+            end
+        ensure
+            @output.close
+            @output.unlink
+        end
+    end
+
+    def add (command)
+        @buildSettings[:docker] << command
+    end
+
+    def fileAdd (source, destination)
+        @buildSettings[:files][source] = destination
+        add "ADD #{destination} #{destination}"
+    end 
+
+    def set (setting, value)
+        @buildSettings[:settings][setting] = value
+    end
+
+    def on (name)
+        if name != @buildStage
+            return
+        end
+        yield
+    end
+    
+    def merge (other)
+        newInfo = @buildSettings.merge(other.buildSettings) do |key, old, newVal|
+            if key == :settings
+                old.merge newVal
+            elsif key == :files
+                old.merge newVal
+            elsif key == :docker
+                old.concat newVal
+            end
+        end
+        @buildSettings = newInfo
+        @volumes = other.volumes.merge @volumes
+        
+    end
+
+    def attach(localDir, volume)
+        if localDir == 'pwd'
+            localDir = @cwd
+        end
+        @volumes[volume] = localDir
+    end
+
+    def gatherVolume(stage)
+        @volumes
+    end
+
+    def setEnvFile(env)
+        if env.nil?
+            @env = Hash[]
+            return
+        end
+        File.open(env, 'r') do |fi|
+            @env = JSON.parse(fi.read)
+        end
+    end
+
+    def cmd (cmd)
+        add "CMD #{cmd}"
+    end
+end

data/src/dsl/eval.rb

@@ -0,0 +1,14 @@
+require_relative 'Shuttl'
+require_relative 'buildContext'
+
+class ShuttlDSL
+  
+    def self.load(filename, stage)
+      builder = Builder.new File.dirname(filename), stage
+      dsl = Shuttl.new builder
+      dsl.instance_eval(File.read(filename), filename)
+      return builder
+    end
+
+end
+

data/src/settings.rb

@@ -0,0 +1,4 @@
+module ShuttlSettings
+    VERSION = "0.3.1"
+    BUILD = 1
+end

metadata

@@ -0,0 +1,115 @@
+--- !ruby/object:Gem::Specification
+name: shuttl
+version: !ruby/object:Gem::Version
+  version: 0.3.1
+platform: ruby
+authors:
+- Yoseph Radding
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2010-04-28 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: docker-api
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.34.0
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.34.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.34.0
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.34.0
+- !ruby/object:Gem::Dependency
+  name: colorize
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.8.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.8.1
+- !ruby/object:Gem::Dependency
+  name: rubyzip
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.2.0
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.2.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.2.0
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.2.0
+description: Shuttl builds doccker images easily
+email: yoseph@shuttl.io
+executables:
+- shuttl
+extensions: []
+extra_rdoc_files: []
+files:
+- bin/shuttl
+- src/Shuttl/Loader.rb
+- src/Shuttl/Shuttl.rb
+- src/commands/base.rb
+- src/commands/build.rb
+- src/commands/deploy.rb
+- src/commands/info.rb
+- src/commands/install.rb
+- src/commands/run.rb
+- src/commands/ssh.rb
+- src/commands/start.rb
+- src/commands/stop.rb
+- src/dsl/Shuttl.rb
+- src/dsl/buildContext.rb
+- src/dsl/eval.rb
+- src/main.rb
+- src/settings.rb
+homepage: https://github.com/shuttl-io/shuttl-cli
+licenses:
+- MIT
+metadata: {}
+post_install_message: Thanks for installing! Run shuttl install to complete the install
+rdoc_options: []
+require_paths:
+- src
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.1
+signing_key: 
+specification_version: 4
+summary: Shuttl!
+test_files: []