greenhouse 0.0.3

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 275b120e3a88469a7c59a1ef80c34e8e53684599
+  data.tar.gz: 3e5d0d6545c76c9d127252c20616277ccd338c9d
+SHA512:
+  metadata.gz: b821db4b17049bc511b15af85f48a7810d22b45b8578aeddb47baf89b30ea54f99f88e4de727875639a322f40640477399cb6e58d107bb22fbf1c852070aca60
+  data.tar.gz: 15da3ce7567ce8ac67789d9f839dd202649bbef426c6d3a29571ebadf4286d4e60d27c02bc7d227e81b7a94d7efd8b490c9621e30cee25dec56ab8881395e05f

data/bin/greenhouse

@@ -0,0 +1,9 @@
+#!/usr/bin/env ruby
+#
+# Greenhouse
+#
+$:.unshift File.expand_path("../../lib", __FILE__)
+
+require 'greenhouse'
+
+Greenhouse::CLI::start

data/lib/greenhouse/cli.rb

@@ -0,0 +1,88 @@
+module Greenhouse
+  class CLI
+    include Scripts::Script
+
+    valid_arguments("-v")
+
+    def self.verbose
+      @verbose || false
+    end
+    
+    def self.verbose?
+      verbose == true
+    end
+
+    def self.verbose=(v)
+      @verbose = v
+      @verbose
+    end
+
+    def self.exec(cmd)
+      if verbose?
+        system cmd
+      else
+        `#{cmd}`
+      end
+    end
+    
+    def self.arguments(*args)
+      keep = []
+      args.each_with_index do |arg,a|
+        if Commands::exists?(arg)
+          begin
+            @command = Commands::command(arg)
+            @command.arguments(*args.slice(a+1,args.length-a))
+          rescue Scripts::InvalidArgument => e
+            puts e.message
+            Commands::command(arg).usage
+            exit 1
+          end
+          break
+        end
+        keep << arg
+      end
+      super(*keep)
+    end
+
+    def self.binary=(bin)
+      @binary = bin
+    end
+
+    def self.binary
+      @binary ||= "greenhouse"
+    end
+
+    def self.command_name
+      binary
+    end
+
+    def self.usage
+      puts <<USAGE
+usage: #{command_name} #{valid_arguments.to_s} <command> [<args>]
+        
+The available greenhouse commands are:
+USAGE
+
+      Commands::commands.each do |cmd|
+        print "   %-#{Commands::commands.sort { |a,b| a.command_name.length <=> b.command_name.length }.last.command_name.length + 2}s" % cmd.command_name
+        puts cmd.command_summary
+      end
+
+      puts
+      puts "See `#{command_name} help <command>` for more information on a specific command."
+    end
+    
+    def self.start
+      arguments(*ARGV)
+      verbose = arguments.map(&:key).include?("-v")
+      
+      if @command.nil?
+        usage
+        exit 1
+      end
+
+      @command.run
+    end
+  
+  end
+end

data/lib/greenhouse/commands/add.rb

@@ -0,0 +1,32 @@
+module Greenhouse
+  module Commands
+    class Add
+      include Command
+      command_summary "Add a project to the ecosystem"
+      
+      def add_another?
+        another = nil
+        while !['', 'n','no'].include?(another) do
+          puts "The following projects are configured in your ecosystem: "
+          #Projects::projects.each do |project|
+          #  puts
+          #  Tasks::ProjectStatus.perform(project)
+          #end
+          Projects.projects.each do |project|
+            puts "    \e[36m#{project.title}\e[0m"
+          end
+          puts
+          print "Would you like to add another project? ([y]es/[N]o): "
+          another = STDIN.gets.chomp.downcase
+          Tasks::AddProject.perform if ['y','yes'].include?(another)
+        end
+      end
+
+      def run
+        Tasks::AddProject.perform
+
+        add_another?
+      end
+    end
+  end
+end

data/lib/greenhouse/commands/command.rb

@@ -0,0 +1,88 @@
+module Greenhouse
+  module Commands
+    module Command
+      def self.included(base)
+        Commands::commands << base # Keep track of all commands
+
+        base.send :include, Scripts::Script
+        base.send :extend, ClassMethods
+        base.send :include, InstanceMethods
+      end
+
+      module ClassMethods
+        def command_name(n=nil)
+          @command_name = n unless n.nil?
+          return @command_name unless @command_name.nil?
+          self.name.underscore.split("/").last
+        end
+        
+        def command_summary(summary=nil)
+          @command_summary = summary unless summary.nil?
+          @command_summary
+        end
+
+        def usage
+          puts "usage: #{::Greenhouse::CLI.command_name} #{command_name} #{valid_arguments.to_s}"
+        end
+
+        def run
+          begin
+            @command ||= new
+            before_hooks.each { |block| @command.instance_eval(&block) }
+            @command.run
+            after_hooks.each { |block| @command.instance_eval(&block) }
+          rescue Exception => e
+            puts e.message
+            @command.usage if e.is_a?(Scripts::InvalidArgument)
+            exit 1
+          end
+        end
+
+        def append_after_hook(&block)
+          @after_hooks ||= []
+          @after_hooks << block
+        end
+        alias_method :after_hook, :append_after_hook
+
+        def prepend_after_hook(&block)
+          @after_hooks ||= []
+          @after_hooks.unshift block
+        end
+
+        def after_hooks
+          @after_hooks ||= []
+          @after_hooks
+        end
+
+        def append_before_hook(&block)
+          @before_hooks ||= []
+          @before_hooks << block
+        end
+        alias_method :before_hook, :append_before_hook
+
+        def prepend_before_hook(&block)
+          @before_hooks ||= []
+          @before_hooks.unshift block
+        end
+
+        def before_hooks
+          @before_hooks ||= []
+          @before_hooks
+        end
+
+        def to_arg
+          Scripts::Argument.new(command_name, :summary => command_summary)
+        end
+      end
+
+      module InstanceMethods
+        %w(command_name command_summary usage).each do |method|
+          define_method method do |*args|
+            self.class.send method, *args
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/greenhouse/commands/configure.rb

@@ -0,0 +1,9 @@
+module Greenhouse
+  module Commands
+    class Configure
+      include Command
+      command_summary "Configure your applications with .env files"
+      # exists as a placeholder for now, so forth rail can override it
+    end
+  end
+end

data/lib/greenhouse/commands/help.rb

@@ -0,0 +1,45 @@
+module Greenhouse
+  module Commands
+    class Help
+      include Command
+
+      command_summary "Provides help for greenhouse usage"
+
+      valid_arguments *Commands::commands.map(&:to_arg)
+      validate_arguments false
+
+      def self.usage
+        puts <<USAGE
+usage: #{::Greenhouse::CLI.command_name} #{command_name} <command>
+      
+The available greenhouse commands are:
+USAGE
+        
+        Commands::commands.select { |cmd| cmd != self}.each do |cmd|
+          print "   %-#{Commands::commands.sort { |a,b| a.command_name.length <=> b.command_name.length }.last.command_name.length + 2}s" % cmd.command_name
+          puts "# #{cmd.command_summary}"
+        end
+      end
+
+      def run
+        if arguments.empty?
+          usage
+          return
+        end
+
+        begin
+          cmd = Commands::commands.select { |cmd| cmd.command_name == arguments.first.key.underscore }.first
+          raise if cmd.nil?
+
+          puts cmd.command_summary
+          puts
+          print "    "
+          cmd.usage
+        rescue
+          puts "Invalid Command: #{arguments.first.key.underscore}"
+          usage
+        end
+      end
+    end
+  end
+end

data/lib/greenhouse/commands/init.rb

@@ -0,0 +1,93 @@
+require 'greenhouse/tasks/sync_project'
+
+module Greenhouse
+  module Commands
+    class Init
+      include Command
+      command_summary "Initialize the current directory as a Greenhouse projects directory"
+
+      # Make sure .ignore defaults are set before init
+      before_hook do
+        unless Projects::ignore_file.exists?
+          Projects::ignore_file.open('w') do |f|
+            f.write <<IGNORE
+# Add any files here that are checked into your git repository, but are commonly edited
+# or changed when working in a dev environment.
+#
+# Files will be ignored across all projects with `git --assume-unchanged FILE` and all
+# paths are relative to the project directory.
+#
+# If you wish to commit changes to a file, you may run `git --no-assume-unchanged FILE`
+# to unignore it temporarily, then run `git --assume-unchanged FILE` again when you're
+# done.
+#
+# You may also create a .ignore file within each project directory if you'd like, and
+# the files listed there will only be ignored for that project. Of course anything
+# defined in a project .gitignore file is permanently ignored by git and does not
+# need to be accounted for here.
+
+# Ignore Gemfile so you can point to local ecosystem paths during development without
+# worry of inadvertently committing your Gemfile.
+Gemfile
+
+# Ignore Gemfile.lock (mainly for applications) so that you don't inadvertently commit
+# any development/local gems to the bundle.
+Gemfile.lock
+
+# Ignore your application database config since different devs may be using different
+# setups.
+config/database.yml
+
+# Ignore tmp dir just in case
+tmp/
+IGNORE
+          end
+          Projects::ignore_file.reload
+        end
+      end
+      
+      after_hook do
+        puts
+        puts "New ecosystem initialized in \e[36m#{Projects::path}\e[0m"
+      end
+
+      class << self
+        def usage
+          puts "usage: #{::Greenhouse::CLI.command_name} #{command_name} #{valid_arguments.to_s}"
+        end
+      end
+
+      def add_another?
+        another = nil
+        while !['', 'n','no'].include?(another) do
+          puts "The following projects will be initialized in your ecosystem:"
+          Projects.projects.each do |project|
+            puts "    \e[36m#{project.title}\e[0m"
+          end
+          puts
+          print "Would you like to add another project before initializing? ([y]es/[N]o): "
+          another = STDIN.gets.chomp.downcase
+          Tasks::AddProject.perform if ['y','yes'].include?(another)
+        end
+      end
+
+      def run
+        while Projects.projects.empty? do
+          puts "You must define at least one project for your ecosystem.\n"
+          Tasks::AddProject.perform
+        end
+        
+        # Prompt to add another project
+        add_another?
+        
+        # Sync all projects
+        Projects.projects.each do |project|
+          Tasks::SyncProject.perform(project)
+        end
+
+        # Create a Procfile that uses `greenhouse launch` to launch the app's processes
+        Tasks::GenerateProcfile.perform
+      end
+    end
+  end
+end

data/lib/greenhouse/commands/launch.rb

@@ -0,0 +1,113 @@
+require 'greenhouse/tasks/sync_project'
+
+module Greenhouse
+  module Commands
+    class Launch
+      include Command
+      command_summary "Launch an application's processes using it's Procfile"
+      project_arguments *Projects::applications.map(&:to_arg)
+      valid_arguments *Projects::applications.map { |app| app.procfile.processes.select { |key,process| process.enabled? }.keys }.flatten
+
+      class << self
+        def usage
+          puts <<USAGE
+usage: #{::Greenhouse::CLI.command_name} #{command_name} <application> [<process> [<process> [...]]]
+
+Applications:
+#{project_arguments.to_help}
+USAGE
+        end
+      end
+
+      def run
+        if arguments.empty?
+          puts "Please provide the application you'd like to launch."
+          puts
+          usage
+          return
+        end
+
+        appname = arguments.slice!(0).key
+        app = Projects.applications.select { |app| app.name == appname }.first
+        
+        if app.nil?
+          if Projects.projects.select { |proj| proj.name == appname }.first.nil?
+            puts "The application '#{appname}' does not exist."
+          else
+            puts "The project '#{appname}' is not defined as an application."
+          end
+          puts
+          usage
+          return
+        end
+
+        if !app.exists?
+          puts "The application directory #{app.path} does not exist. Are you sure you've initialized your ecosystem?"
+          puts
+          usage
+          return
+        end
+
+        Signal.trap("HUP") { |signo| quit(signo) }
+        Signal.trap("INT") { |signo| quit(signo) }
+        Signal.trap("KILL") { |signo| quit(signo) }
+        Signal.trap("TERM") { |signo| quit(signo) }
+        
+        begin
+          @procs = {}
+          Bundler.with_clean_env do
+            app.chdir do
+              if app.dotenv.exists?
+                begin
+                  # We have to unset these because foreman sets them by default, and Dotenv won't override a set value
+                  %w(PORT RACK_ENV RAILS_ENV).each { |key| ENV[key] = nil }
+                  require 'dotenv'
+                  Dotenv.load!
+                rescue
+                  puts "\e[31mError parsing .env file for #{app.title}.\e[0m"
+                  exit 1
+                end
+              else
+                puts "\e[33mWarning: No .env file found in #{app.title}!\e[0m"
+                puts "Your application may not behave as expected without a .env file."
+              end
+              
+              unless app.procfile.exists?
+                puts "\e[31mNo Procfile found for #{app.title}\e[0m"
+                exit 1
+              end
+
+              app.procfile.enabled.each do |key,process|
+                next if arguments.length > 0 && !arguments.map(&:key).include?(key)
+                @procs[key] = process
+              end
+
+              arguments.map(&:key).each { |key| puts "Skipping process not found in Procfile: #{key}" unless @procs.keys.include?(key) }
+              @procs.each do |key,process|
+                @procs[key] = fork do
+                  exec process.command
+                end
+              end
+              
+              Process.wait
+            end
+          end
+        rescue
+          quit 1
+        end
+
+      end
+
+      def quit(signo)
+        @procs.each do |key,pid|
+          begin
+            Process.kill("KILL", pid)
+          rescue # make sure to kill all children
+          end
+        end
+        exit signo
+      end
+
+    end
+  end
+end

data/lib/greenhouse/commands/new.rb

@@ -0,0 +1,42 @@
+module Greenhouse
+  module Commands
+    class New
+      include Command
+
+      command_summary "Setup a new Greenhouse projects directory"
+      validate_arguments false
+
+      class << self
+        def usage
+          puts "usage: #{::Greenhouse::CLI.command_name} #{command_name} <name> #{valid_arguments.to_s}"
+        end
+      end
+
+      def run
+        if arguments.length == 0
+          usage
+          exit 1
+        end
+
+        projects_directory = arguments.first.key
+        if File.exists?(projects_directory)
+          STDERR.puts "Directory already exists: #{projects_directory}"
+          STDERR.puts "You can try running `#{::Greenhouse::CLI.command_name} init` from inside the directory."
+          exit 1
+        end
+
+        begin
+          FileUtils.mkdir(projects_directory)
+        rescue
+          STDERR.puts "Unable to create projects directory: #{projects_directory}"
+          exit 1
+        end
+        
+        exec "cd #{projects_directory}; greenhouse init"
+        #Dir.chdir(projects_directory) do
+        #  Init.run
+        #end
+      end
+    end
+  end
+end

data/lib/greenhouse/commands/pull.rb

@@ -0,0 +1,45 @@
+module Greenhouse
+  module Commands
+    class Pull
+      include Command
+      command_summary "Pull and merge remote branches for all projects"
+      project_arguments *Projects::projects.map(&:to_arg)
+      
+      class << self
+        def usage
+          puts <<USAGE
+usage: #{::Greenhouse::CLI.command_name} #{command_name} [<project>] #{valid_arguments.to_s}
+
+Projects:
+#{project_arguments.to_help}
+USAGE
+        end
+      end
+
+      def pull_all
+        if Projects.projects.empty?
+          puts "No projects defined."
+          return
+        end
+
+        Projects.projects.each do |project|
+          Tasks::PullProject.perform(project)
+        end
+      end
+
+      def pull_project(project)
+        unless project.exists?
+          puts "Project \e[36m#{project.title}\e[0m does not exist. Try initializing it with `greenhouse init`"
+          return
+        end
+
+        Tasks::PullProject.perform(project)
+      end
+
+      def run
+        project = Projects::projects.select { |project| arguments.map(&:key).include?(project.name) }.first
+        project.nil? ? pull_all : pull_project(project)
+      end
+    end
+  end
+end

data/lib/greenhouse/commands/purge.rb

@@ -0,0 +1,91 @@
+module Greenhouse
+  module Commands
+    class Purge
+      include ::Greenhouse::Commands::Command
+      command_summary "Purge project directories from your ecosystem allowing you to start from scratch"
+      valid_argument Scripts::Argument.new("-a --all", :summary => "Remove your ecosystem configuration files in addition to project directories (will NOT prompt when combined with -f)")
+      valid_argument Scripts::Argument.new(["-f", "--force"], :summary => "Force the purge, will still prompt if you have local changes or unpushed local branches")
+      project_arguments *Projects::projects.map(&:to_arg)
+      
+      class << self
+        def usage
+          puts <<USAGE
+usage: #{::Greenhouse::CLI.command_name} #{command_name} [<project>] #{valid_arguments.to_s}
+
+Arguments:
+#{valid_arguments.to_help}
+
+Projects:
+#{project_arguments.to_help}
+USAGE
+        end
+      end
+
+      def clean?
+        return false if Projects::projects_file.exists?
+        return false if Projects::ignore_file.exists?
+        return false if Projects::procfile.exists?
+        return false if Projects::projects.any?(&:exists?)
+        true
+      end
+
+      def force?
+        arguments.map(&:key).include?("-f")
+      end
+
+      def purge_all?
+        arguments.map(&:key).include?("-a")
+      end
+      
+      def run
+        app = Projects::projects.select { |project| arguments.map(&:key).include?(project.name) }.first
+        if app.nil?
+          if clean?
+            puts "Nothing to do."
+            return
+          end
+          #return unless force? || prompt
+        
+          purge
+        else
+          Tasks::PurgeProject.perform(app, force?)
+        end
+
+        puts "\e[33mDone\e[0m"
+        return
+      end
+
+      def purge
+        Projects.projects.each do |project|
+          Tasks::PurgeProject.perform(project, force?)
+        end
+
+        Tasks::RemoveGreenhouseFiles.perform(force?) if purge_all?
+      end
+  
+      def prompt
+        puts <<PUTS 
+\e[31mThis will completely clean out the ecosystem, removing all projects and 
+optionally dropping the database and wiping configuration files.\e[0m
+
+PUTS
+        puts <<PUTS
+You will be prompted if you have any uncommitted local changes or unpushed branches
+in any of your projects and may choose to either take action or skip that project
+to avoid losing any work.
+
+PUTS
+        puts <<PUTS
+You will be prompted separately to confirm whether you'd like to drop or keep your
+databases.
+PUTS
+
+        puts
+        print "Are you sure you want to continue? ([y]es/[N]o): "
+        continue = STDIN.gets.chomp.downcase
+        ["y","yes"].include?(continue)
+      end
+    
+    end
+  end
+end