tb-cli 0.1.0

data/.gitignore

@@ -0,0 +1,7 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*
+*.swp
+html
+.yardoc/

data/.yardopts

@@ -0,0 +1 @@
+-m markdown

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in tbox-template.gemspec
+gemspec

data/README.md

@@ -0,0 +1,89 @@
+Torquebox CLI
+=============
+The command-line app for making [Torquebox][1] even louder.
+
+Usage
+-----
+
+    tb [action] [options]
+
+Actions that you can perform are `rack` and `add`, which can be described
+below.
+
+### Add component with `tb add`
+Add a component to your torquebox.yml.  Torquebox provides a number of features
+that make writing Rack and Rails-based applications a breeze, such as messaging
+features, background services, cron-like tasks, and service pooling.
+
+  Types of components can be:
+
+   * `application` - Application types
+   * `web` - WEb configuration settings
+   * `ruby` - version of ruby you want to set, including compilation options
+   * `environment` - add and remove environment variables for the runtime of
+     your JRuby App
+   * `queue` - manipulate queues (create, rename, remove)
+   * `topic` - create a topic
+   * `messaing` - set up handlers for your queues/topics
+   * `task` - create a task with a concurrency setting
+   * `job` - create an external job, including various settings around it
+     (job class, description, crontab)
+   * `service` - Create a long-running service that runs in the background
+   * `auth` - configure your authorization settings
+   * `pooling` - Runtime pooling options
+
+For help with any component you want to add, you can get help by typing `tb add
+help [component]`, and you'll get some help.
+
+### Create baseline Torquebox-Rack app with `tb rack`
+Generate a Rack-based application.  A normal Rack-based Torquebox application
+only needs a few files, which this generator helps fill out for you:
+
+   * `project_name` folder
+   * `project_name/config.ru` - Your Rackup file
+   * `project_name/lib` directory
+   * `project_name/app.rb` base application file that starts Rack
+   * `project_name/Rakefile` with [Torquebox specific rake tasks][3]
+   * `project_name/torquebox.yml` - Your Torquebox config file
+   * `project_name/Gemfile` if you decide to use it as a Gem
+
+
+More Help
+=========
+
+If you are unfamiliar with the layout of the `torquebox.yml` file or don't know
+what all this gobbledygook means, you can always reference the torquebox documentation, from
+which much of this application is based off of.
+
+http://torquebox.org/documentation/
+
+Why
+---
+Torquebox is a really awesome project and I was interested in doing something
+with it.  Since there didn't appear to be any project-generator-type
+thing in place, I decided to make one.  This is as much an experiment with
+[Thor][2] as it is an interest in providing Torquebox a command-line application
+to spin up TB apps quickly.
+
+Obviously, if you find bugs, report them, throw a pull request my way, and
+feel free to critique the hell out of this.  This is my first project in the
+Ruby space, and I'm more interested in making this a good app, even if it's not
+entirely useful to anybody.
+
+### Note:
+I have no tests at all for this.  I'm interested in trying to test it, but I'm
+not entirely sure how I would test a command-line app when much of it's
+functionality is wrapped in Thor (which I trust to do its job) tasks and such.
+
+To Do
+=====
+I don't have an interest in adding too many more features, but I have a small list of things
+I'd like to include to fill it out a bit:
+
+  * wrap [rake tasks][3]
+  * include the [rails template generator][4] provided by the Torquebox team
+
+  [1]: http://www.torquebox.org/
+  [2]: http://www.github.com/wycats/thor
+  [3]: http://torquebox.org/documentation/1.0.1/deployment.html#deploy-using-rake
+  [4]: http://torquebox.org/documentation/1.0.1/web.html#using-the-rails-application-template

data/Rakefile

@@ -0,0 +1,18 @@
+gem 'rdoc'
+require 'rdoc/task'
+require 'rake/clean'
+require 'bundler'
+
+Bundler::GemHelper.install_tasks
+
+CLEAN.include('*.tmp')
+CLOBBER.include('*.tmp', 'pkg/', 'html/')
+
+# Default is to build and generate docs.  No tests yet, so can't do that
+task :default => ["build", "rdoc"]
+
+# Document gem and place in html/
+Rake::RDocTask.new do |rd|
+  rd.main = "README.md"
+  rd.rdoc_files.include("lib/**/*.rb", "README.md")
+end

data/bin/tb

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+$: << File.expand_path(File.dirname(__FILE__) + "/../lib")
+
+require 'tb-cli'

data/lib/tb-cli.rb

@@ -0,0 +1,47 @@
+$: << File.expand_path(File.dirname(__FILE__) + "/../lib")
+require 'rubygems'
+require 'thor'
+require 'thor/group'
+
+module Tbox
+  # Base Command Line interface.  Registers the two major Thor tasks (Rack and
+  # Add).
+  class Cli < Thor
+    require 'tb-cli/camel_case'
+    require 'tb-cli/descriptions'
+    require 'tb-cli/cli/add'
+    require 'tb-cli/cli/rack'
+    require 'tb-cli/config_file'
+
+    register Tbox::Add, "add", "add [component]", ADD
+    register Tbox::Rack, "rack", "rack [project_name]", RACK
+
+    # Default help message when nothing is passed in
+    def help(meth=nil)
+      puts BANNER
+      super
+    end
+
+    # override the Basic shell with the colorized one in Thor
+    def self.start(*)
+      Thor::Base.shell = Thor::Shell::Color
+      super
+    end
+
+    # Default Help Message banner.
+    BANNER = <<-BAN
+Torquebox CLI  
+
+  tb [action] [options]     # See below for more details on actions
+
+Use this template generator to make quick Rack applications.  If you want a 
+rails app, please use the application template provided by Torquebox 
+(http://torquebox.org/documentation/DEV/rails.html#using-the-rails-application-template):
+
+  rails new my_app -m $TORQUEBOX_HOME/share/rails/template.rb
+
+    BAN
+
+  end
+end
+Tbox::Cli.start

data/lib/tb-cli/camel_case.rb

@@ -0,0 +1,18 @@
+# See the 'tb-cli/cli/rack' module for initializing Rack-based projects to see
+# where this modification is being used.
+class String
+
+  # Stolen from StackOverflow: http://stackoverflow.com/questions/1509915/converting-camel-case-to-underscore-case-in-ruby
+  # 
+  # This converts a string from CamelCase to snake_case.  This allows all String
+  # classes to call #underscore to get a proper conversion.
+  #
+  def underscore
+    self.gsub(/::/, '/').
+      gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+      gsub(/([a-z\d])([A-Z])/,'\1_\2').
+      tr("-", "_").
+      downcase
+  end
+end
+

data/lib/tb-cli/cli/add.rb

@@ -0,0 +1,256 @@
+module Tbox
+  # Class for adding components to your `torquebox.yml`, `queues.yml` or
+  # `topics.yml` file.
+  class Add < Thor
+    include Thor::Actions
+
+    desc "add application", "Application"
+    long_desc <<-DESC
+      Add an application component descriptor to your project.  See
+
+      http://torquebox.org/documentation/1.0.1/deployment-descriptors.html#general-application-config-in-descriptor
+
+      for more details.  The two options you have at your disposal are:
+
+      root_loc: location for your project (/path/to/my/app) 
+      env: your environment (development, test, production) 
+    DESC
+    method_option :root_loc, :type => :string, :desc => "root for your application"
+    method_option :env, :type => :string, :desc => "Environment to run under (development, test, production)"
+    def application
+      y = ConfigFile.new destination_root
+      if options.root_loc || options.env
+        y.add_config('application', 'root', options.root_loc) if options.root_loc
+        y.add_config('application', 'env', options.env) if options.env
+        replace_yaml(y.yaml)
+      else
+        puts "You need to specify either --root-loc or --env"
+      end
+    end
+
+    desc "add web", "Web"
+    long_desc <<-DESC
+    Add web-specific configuration to your application.  Since Torquebox can deploy multiple applications
+    under one hostname, extra configuration options are allowed to make deployment easier.  If you want to 
+    specify the specific 'rackup.ru' script for your app, configure with --rackup=location.  You can specify
+    a specific context that this application will be avaialble for (such as /application) by using --context.
+
+    Virtual hosts can also be configured with the --host option.  Finally, you can also specify a location for
+    your static web content can be pointed to by using the --static=location option.
+
+    See http://torquebox.org/documentation/1.0.1/deployment-descriptors.html#web-specific-config-in-descriptor
+    for more details.
+    DESC
+    method_option :rackup, :type => :string, :default => "config.ru", :desc => "Rackup file (default config.ru)"
+    method_option :host, :type => :string, :default => "localhost", :desc => "virtual host to run as (default localhost)"
+    method_option :context, :type => :string, :default => "/", :desc => "path under http://host/ to deploy to (default: '/')"
+    method_option :static, :type => :string, :desc => "Any static web content provided should be put here (default: none)"
+    def web
+      y = ConfigFile.new destination_root
+      y.add_config('web', 'rackup', options.rackup) if options.rackup
+      y.add_config('web', 'host', options.host) if options.host
+      y.add_config('web', 'context', options.context) if options.context
+      y.add_config('web', 'static', options.static) if options.static
+      replace_yaml(y.yaml)
+    end
+
+    desc "add ruby", "Ruby"
+    long_desc <<-DESC
+    Add Ruby runtime configurations for your web application.  JRuby allows for a couple different runtime options:
+    Ruby interpreter version (1.8 or 1.9 through --version), and compile mode (jit, force, off) through --compile_mode.
+
+    See http://torquebox.org/documentation/1.0.1/deployment-descriptors.html#ruby-runtime-config-in-descriptor
+    for more details.
+    DESC
+    method_option :version, :type => :numeric, :desc => "Ruby interpreter version, either 1.8 or 1.9"
+    method_option :compile_mode, :type => :string, :desc => "Compile mode (jit, force, or off)"
+    def ruby
+      y = ConfigFile.new destination_root
+      if [ 1.8, 1.9 ].include? options.version
+        y.add_config('ruby', 'version', options.version)
+      end
+      if [ 'jit', 'force', 'off' ].include? options.compile_mode
+        y.add_config('ruby', 'compile_mode', options.compile_mode)
+      end
+      replace_yaml(y.yaml)
+    end
+
+    desc "add environment", "Add an environment variable, such as MAIL_HOST or REPLY_TO"
+    method_option :options, :type => :hash, :desc => "Add options as you need them: --options=MAIL_HOST:server REPLY_TO:emailaddress, etc., etc."
+    def environment
+      y = ConfigFile.new destination_root
+      options.options.each_pair { |k,v|
+        y.add_config('environment', k, v)
+      }
+      replace_yaml(y.yaml)
+    end
+
+    desc "add queue", "Add a Queue to your application"
+    long_desc <<-DESC
+    Queues are a messaging component that can be often used in load balancing situations.  For sending and receiving
+    messages, you define a topic to queue up all of the work to be done, and subscribe a number of queue handlers
+    to retrieve messages off of the queue as the work arrives.  Adding a queue to your application is pretty easy. 
+    Just add the --name=queue_name.  An additional option --not_durable, can be appended to prevent any messages from
+    being written to disk in case of server failure.  By default, all queues are durable, but if you want to disable this
+    functionality, you can do so.
+
+    Much more detailed documentation on queues and topics can be found on the Torquebox site, including documentation
+    on how to interact with a queue, sending and receiving messages and the like:
+
+    http://torquebox.org/documentation/1.0.1/messaging.html
+    DESC
+    method_option :name, :type => :string, :required => true
+    method_option :not_durable, :type => :boolean, :default => false, :desc => "Disable Durable subscriber (at your own risk)"
+    def queue
+      # TODO: Add external queues and hosts (see section 7.2.3.3 for details)
+      file = 'queues.yml'
+      y = ConfigFile.new destination_root, file
+      if (options.not_durable && options.name)
+        y.add_config("/queues/#{options.name}", "durable: #{!options.not_durable}")
+      elsif (options.name)
+        y.add_config("/queues/#{options.name}")
+      end
+      replace_yaml(y.yaml, file) 
+    end
+
+    desc "add topic", "Add a Topic to your application"
+    long_desc <<-DESC
+    Topics are similar to Queues, except that they follow the pub-sub model for messaging.  Currently, the only 
+    option allowed is --name=name_of_topic.  Much more documentation can be found on how to use Topics and Queues,
+    and how they fit into Torquebox on their website:
+
+    http://torquebox.org/documentation/1.0.1/messaging.html
+    DESC
+    method_option :name, :type => :string, :required => true
+    def topic
+      # TODO: Add external queues and hosts (see section 7.2.3.3 for details)
+      file = 'topics.yml'
+      y = ConfigFile.new destination_root, file
+      y.add_config("/topics/#{options.name}")
+      replace_yaml(y.yaml, file)
+    end
+
+    desc "add messaging", "Add Messaging handlers for your queues and topics"
+    long_desc <<-DESC
+    Handlers are classes that consume messages on either topics or queues.  Defining which classes are going to handle
+    these messages can be done by specifying the --queue=name_of_queue, as well as the --handler_class=ClassName to
+    provide a handler for.
+
+    As always, documentation for Message Processors can be found on the Torquebox site:
+    http://torquebox.org/documentation/LATEST/messaging.html#messaging-consumers
+    DESC
+    method_option :queue, :type => :string, :desc => "Name of the queue (/queues/my_queue_name:)"
+    method_option :topic, :type => :string, :desc => "Name of the topic (/topics/my_topic_name:)"
+    method_option :handler_class, :type => :string
+    def messaging
+      if options.queue == nil && options.topic == nil
+        puts "You must specify either a topic or a queue you're configuring a handler for"
+      else
+        if options.handler_class
+          y = ConfigFile.new destination_root
+          messaging = y.add_config["messaging"] || {}
+          if options.queue
+            messaging[options.queue] = options.handler_class
+          elsif options.topic
+            messaging[options.topic] = options.handler_class
+          end
+          y.add_config["messaging"] = messaging
+          puts y.yaml
+          replace_yaml(y.yaml)
+        else
+          puts "You must specify a --handler-class"
+        end
+      end
+    end
+
+    desc "add task", "Add a Task"
+    method_option :name, :type => :string, :desc => "Class Name of Task (MyTaskName)", :required => true
+    method_option :concurrency, :type => :numeric, :desc => "Number of concurrent messages you want to handle"
+    def task
+      y = ConfigFile.new destination_root
+      if options.concurrency
+        y.add_config('tasks', options.name, { "concurrency" => options.concurrency })
+      else
+        y.add_config('tasks', options.name)
+      end
+      replace_yaml(y.yaml)
+    end
+
+    desc "add job", "Add a scheduled job"
+    method_option :job_name, :type => :string, :required => true
+    method_option :job_class, :type => :string, :required => true, :desc => "Class for the Job (Mail::Notifier)"
+    method_option :cron, :type => :string, :required => true, 
+                  :desc => "crontab-like entry,  Similar to the following: '0 */5 * * * ?'"
+    method_option :description, :type => :string, :desc => "Optional Description"
+    def job
+      y = ConfigFile.new destination_root
+      opts = {}
+      opts['job'] = options.job_class
+      opts['cron'] = options.cron
+      opts['description'] = options.description if options.description
+      y.add_config('jobs', options.job_name, opts)
+      replace_yaml(y.yaml)
+    end
+
+    desc "add service", "Add a background service"
+    method_option :name, :type => :string, :desc => "Service Name", :required => true
+    method_option :params, :type => :hash, :desc => "key:value pairs to supply for this service"
+    method_option :singleton, :type => :boolean, :desc => "Will this be a singleton operation?", :default => false
+    def service
+      y = ConfigFile.new destination_root
+      opts = options.params
+      opts["singleton"] = true if options.singleton
+      y.add_config('services', options.name, opts)
+      replace_yaml(y.yaml)
+    end
+
+    desc "add auth", "Auth"
+    method_option :auth_type, :type => :string, :desc => "Authentication type", :required => true
+    method_option :domain, :type => :string, :desc => "domain to authenticate against", :required => true
+    def auth
+      y = ConfigFile.new destination_root
+      y.add_config('auth', options.auth_type, { "domain" => options.domain })
+      replace_yaml(y.yaml)
+    end
+
+    desc "add pooling", "Pooling"
+    method_option :subsystem, :type => :string, :desc => "Subsystem type (web, jobs, messaging, services)",
+      :required => true
+    method_option :bounded, :type => :hash, :desc => "min:1, max:3, etc"
+    method_option :shared, :type => :boolean, :desc => "use this if not using bounded pooling"
+    method_option :global, :type => :boolean, :desc => "if not using bounded or shared"
+    def pooling
+      y = ConfigFile.new destination_root
+      thing = {}
+      thing["pooling"] = {}
+      if [ 'web', 'jobs', 'messaging', 'services' ].include? options.subsystem
+        if options.bounded
+          y.add_config('pooling', options.subsystem, options.bounded)
+        elsif options.shared
+          y.add_config('pooling', options.subsystem, 'shared')
+        elsif options.global
+          y.add_config('pooling', options.subsystem, 'global')
+        end
+        replace_yaml(y.yaml)
+      else
+        puts "subsystem must be one of: web, job, messaging, or services"
+      end
+    end
+
+    def help(meth=nil)
+      puts INIT
+      super
+    end
+
+    no_tasks do
+
+      def replace_yaml(yaml_f, file='torquebox.yml')
+        puts "Saving:\n"
+        remove_file(file)
+        create_file(file, yaml_f)
+      end
+    end
+  end
+end
+
+

data/lib/tb-cli/cli/rack.rb

@@ -0,0 +1,51 @@
+module Tbox
+  ## Rack tasks for your application.
+  class Rack < Thor
+
+    # For use with generating Rack-based projects
+    include Thor::Actions
+
+    default_task :init
+
+    desc "init", "Initialize a new Rack-based Application"
+    # Initialize a new Rack-based Application
+    def init
+      setup = yes? "Would you like to set up a new Rack-based Application?"
+      if setup
+        say "awesome!", Thor::Color::BOLD + Thor::Color::RED, false
+        say " let's get to work"
+        @project = ask "Name of project: " 
+        if @project
+          gen_project @project
+        else
+          say "You need to supply a project name"
+        end
+      else
+        say "Shucks"
+      end
+    end
+
+    no_tasks do
+
+      # Generates a new project with the provided name:
+      #   [project_name]   Name of the project and subsequent folder to create
+      #                    the project for
+      def gen_project(project_name)
+        say_status "new_project", project_name
+        Tbox::Rack.source_root(File.expand_path(File.join(__FILE__, "..", "..")))
+        empty_directory(project_name)
+        empty_directory(project_name + "/lib")
+        %w{ app.rb config.ru Rakefile torquebox.yml README Gemfile }.each { |f|
+          template("templates/#{f}.tt", "#{project_name}/#{f}")
+        }
+      end
+
+      def method_missing(name, *args) # :nodoc:
+        @project = name.to_s.underscore
+        gen_project name.to_s.underscore
+      end
+    end
+
+  end
+end
+

data/lib/tb-cli/config_file.rb

@@ -0,0 +1,76 @@
+module Tbox
+  # ConfigFile class provides some simple YAML configuration file helpers.
+  # While normal YAML methods within Ruby are fine (and used heavily), these
+  # helpers assist in adding, removing, and replacing configurations for the
+  # Torquebox.yml default specification file.  These methods make adding
+  # a config to the torquebox.yml much easier, as it abstracts out the details
+  # of having to know the underlying data structure (Hashes, Arrays, boolean,
+  # string) and just pass in to this ConfigFile the pieces you want to add
+  class ConfigFile
+    require 'yaml'
+
+    attr_accessor :config, :torquebox_yml
+
+    # Create and/or open a YAML configuration file
+    # [destination_root] Directory that you will find the YAML file
+    # [file] Filename of the YAML file to load
+    def initialize(destination_root=nil, file='torquebox.yml')
+      @filename = file
+      @torquebox_yml = File.join(destination_root, @filename)
+      if config_present?
+        @config = YAML.load_file @torquebox_yml
+      else
+        @config = {}
+      end
+    end
+
+    # Is the configuration file there or does a new config there to laod?
+    def config_present?
+      File.exist? @torquebox_yml
+    end
+
+    # Convert config to YAML
+    def yaml
+      @config.to_yaml
+    end
+
+    # Dynamically adds to the config object based on what was passed in through
+    # Thor
+    #
+    # @param [Thor::CoreExt::HashWithIndifferentAccess] options options hash given to you by Thor
+    # @param [String] meth string of the method passed in
+    # @param [String] config what the config for that method sets
+    # @param [String] value value assocated with it
+    #
+    # @return [String] the YAML output for this config, e.g.:
+    #     options = HashWithIndifferentAccess.new 'topic' => 'some_topic_name'
+    #     add_config(options, "topics", "topic"
+    #
+    #     ---
+    #     topics:
+    #       some_topic_name:
+    def add_config(root, config=nil, value=nil)
+      conf = @config[root.to_s] || {}
+      conf[config.to_s] = value if config
+      @config[root.to_s] = nil  # Some attributes need no settings and just exist, like queues.yml
+      @config[root.to_s] = conf unless conf.empty?
+      puts "Current #{@filename} configuration file:\n\n#{yaml}\n"
+    end
+
+    # Not tested or documented
+    def remove_config(meth, config)
+      conf = @config[meth.to_s]
+      unless conf
+        puts "No such config available for #{meth}"
+      else
+        puts "removing config \n\t#{config}"
+        begin
+          @config.delete(config)
+        rescue e
+          puts "No such config #{config} to remove, skipping..."
+        end
+      end
+    end
+  end
+end
+

data/lib/tb-cli/descriptions.rb

@@ -0,0 +1,55 @@
+# Description for when you pass in the 'add' method execution.
+ADD = <<-COMPONENT
+Add a new component to the torquebox.yml file.  The type of component can be:
+
+  - application
+  - web
+  - ruby
+  - environment
+  - queue
+  - topic
+  - messaging
+  - task
+  - job
+  - service
+  - auth
+  - pooling
+
+For more help on a particular subcommand, enter
+
+  tb add help [component]
+
+COMPONENT
+
+MESSAGING_LONG = <<-MSG
+Messaging
+=========
+For more information, go to (http://torquebox.org/documentation/1.0.0/messaging.html#messaging-consumers) for information (figure 8.15, specifically):
+
+  messaging:
+    /queues/foo:
+      MyFooHandler:
+        filter: "cost > 30"
+        config:
+          type: "premium"
+          season: "fall"
+        concurrency: 2
+    /topics/bar:
+      MyBarHandler:
+        durable: true
+
+MSG
+
+RACK = <<-RCK
+Create a new Rack Application template.  By default, will generate the following:
+
+  project_folder
+  |- app.rb         (Application stub)
+  |- config.ru      (Rackup file)
+  |- Rakefile       (Rake with Torquebox configs)
+  |- torquebox.yml  (Torquebox config)
+
+Much of this would be much similar to a rails app, but if you 
+have an interest in doing something more lightweight, you might
+find this template more appealing and minimal.
+RCK

data/lib/tb-cli/templates/Gemfile.tt

@@ -0,0 +1,6 @@
+gem 'jdbc-sqlite3'
+gem 'jruby-openssl'
+
+gem 'torquebox-rake-support'
+gem 'torquebox'
+

data/lib/tb-cli/templates/README.tt

@@ -0,0 +1,21 @@
+Here's a new application
+========================
+
+Nothing fancy, so if you're looking for more details on how to 
+actually generate a nice Torquebox project, there is a wealth
+of good information to be found in the Torquebox documentation:
+
+  http://torquebox.org/documentation/1.0.0
+
+What's in this project?
+-----------------------
+
+Here are currently a handful of base files to make your first
+Torquebox app:
+
+  - app.rb          Your Application
+  - config.ru       Your Rackup file (see http://m.onkey.org/ruby-on-rack-1-hello-rack)
+  - Gemfile         include the torquebox and torquebox-rake-support gems
+  - Rakefile        See http://torquebox.org/documentation/1.0.0/deployment.html#deploy-using-rake
+  - torquebox.yml   Your Torquebox YAML file for configuring all the fancy Torquebox-y things
+  - README          This file

data/lib/tb-cli/templates/Rakefile.tt

@@ -0,0 +1 @@
+require 'torquebox/rake/tasks'

data/lib/tb-cli/templates/app.rb.tt

@@ -0,0 +1,9 @@
+require 'sinatra/base'
+
+class <%= @project.capitalize %> < Sinatra::Base
+
+  get '/' do
+    'Hello world!'
+  end
+
+end

data/lib/tb-cli/templates/config.ru.tt

@@ -0,0 +1,2 @@
+require 'app'
+run <%= @project.capitalize %>

data/lib/tb-cli/templates/fully-exploded-torquebox.yml.tt

@@ -0,0 +1,106 @@
+application:
+  root: /path/to/myapp
+  env: development
+
+web:
+  rackup: alternative/path/to/my_config.ru
+  context: /app-one
+  static: public
+  host: www.host-one.com
+
+ruby:
+  version: 1.9
+  compile_mode: off
+
+environment:
+  MAIL_HOST: mail.yourhost.com
+  REPLY_TO: you@yourhost.com
+
+queues:
+  /queues/my_app_queue:
+
+topics:
+  /queues/my_app_topic:
+
+messaging:
+  # Simple messaging:
+  /queues/my_app_queue:     MyFooHandler
+  /topics/long_lived_topic: MyBazHandler
+  # Set options in messaging:
+  /queues/foo:
+    MyFooHandler:
+      filter: "cost > 30"
+      config:
+        type: "premium"
+        season: "fall"
+      concurrency: 2
+  /topics/bar:
+    MyBarHandler:
+      durable: true
+  # Advanced Setup 
+  /topics/simple: SimpleHandler
+
+  /topics/popular:
+      - Handler
+          concurrency: 5
+      - Observer: &defaults
+          filter: "x > 18"
+          config:
+            x: ex
+            y: why
+      - Processor
+
+  /queues/students:
+    VerySimpleAnalyzer:
+    YouthMonitor:
+      filter: "y < 18"
+      config:
+        h: ache
+        i: eye
+    LookAndFeel:
+      <<: *defaults
+
+
+tasks:
+  SomeTask:
+    concurrency: 2
+  SomeOtherTask:
+    concurrency: 5
+
+jobs:
+  mail.notifier:
+    job:         Mail::Notifier
+    cron:        '0 */5 * * * ?'
+    description: Deliver queued mail notifications
+
+services:
+  MyService:
+    name: TorqueBox User
+
+  AnotherService:
+    singleton: true   # Enable High Availability
+
+auth:
+  default:
+    domain: hornetq
+  jmx:
+    domain: jmx-console
+
+pooling:
+  web:               # Bounded pool with upper and lower limit
+    min: 3
+    max: 10
+  web: shared        # A shared pool is also an option
+  web: global        # A global pool
+  # Default pooling config for an app in development mode
+  jobs: 
+    min: 1
+    max: 2
+  messaging:
+    min: 1
+    max: 2
+  web: shared
+  # Default pooling config for a non-development deployment
+  jobs: shared
+  messaging: shared
+  web: shared

data/lib/tb-cli/templates/template.rb

@@ -0,0 +1,74 @@
+if ( Rails::VERSION::MAJOR == 2 )
+  gem "activerecord-jdbc-adapter", :lib => "arjdbc"
+else
+  text = File.read 'Gemfile'
+  File.open('Gemfile', 'w') {|f| f << text.gsub(/^(gem 'sqlite3)/, '# \1') }
+  gem "activerecord-jdbc-adapter", :require => "arjdbc"
+  gem "jdbc-sqlite3"
+  gem "jruby-openssl"
+end
+
+# gems defs common to v2 and v3
+gem "torquebox-rake-support"
+gem 'torquebox'
+
+
+if ( Rails::VERSION::MAJOR == 2 )
+  initializer("session_store.rb") do
+    <<-INIT
+# Configure the TorqueBox Servlet-based session store.
+# Provides for server-based, in-memory, cluster-compatible sessions.
+( ActionController::Base.session_store = TorqueBox::Session::ServletStore ) if defined?(TorqueBox::Session::ServletStore)
+    INIT
+  end
+else
+  remove_file( 'config/initializers/session_store.rb' )
+  initializer("session_store.rb") do
+    <<-INIT
+# Configure the TorqueBox Servlet-based session store.
+# Provides for server-based, in-memory, cluster-compatible sessions
+#{app_const}.config.session_store TorqueBox::Session::ServletStore if defined?(TorqueBox::Session::ServletStore)
+    INIT
+  end
+end
+
+initializer("active_record_backgroundable.rb") do
+  <<-INIT
+# Enable backgroundable methods for ActiveRecord classes. Provides:
+# class AModel < ActiveRecord::Base
+#   always_background :a_method
+# end
+# 
+# a_model_instance.background.another_method
+if defined?(TorqueBox::Messaging::Backgroundable) && defined?(ActiveRecord::Base)
+  ActiveRecord::Base.send(:include, TorqueBox::Messaging::Backgroundable)
+end
+  INIT
+end
+
+# Create app/tasks and app/jobs, just for fun
+inside('app') {
+  FileUtils.mkdir %w( tasks jobs )
+}
+
+# We need the app to find the rake tasks
+rakefile( 'torquebox.rake' ) do
+  <<-TASK
+
+begin
+  require 'torquebox-rake-support'
+rescue LoadError => ex
+  puts "Failed to load the TorqueBox rake gem (torquebox-rake-support). Make sure it is available in your environment."
+end
+
+# Patch db:load_config to make sure activerecord-jdbc-adapter gets loaded
+namespace :db do
+  task :load_config => :rails_env do
+    require 'active_record'
+    require 'activerecord-jdbc-adapter'
+    ActiveRecord::Base.configurations = Rails::Application.config.database_configuration
+  end
+end
+
+  TASK
+end

data/lib/tb-cli/templates/torquebox.yml.tt

@@ -0,0 +1,3 @@
+application:
+  root: /<%= @project.downcase %>
+  env: development

data/lib/tb-cli/version.rb

@@ -0,0 +1,6 @@
+module Tbox
+  module Cli
+    # Version of the application
+    VERSION = "0.1.0"
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,3 @@
+require 'rspec'
+require 'thor'
+

data/tb-cli.gemspec

@@ -0,0 +1,31 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "tb-cli/version"
+
+Gem::Specification.new do |s|
+  s.name        = "tb-cli"
+  s.version     = Tbox::Cli::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Nick Klauer"]
+  s.email       = ["klauer@gmail.com"]
+  s.homepage    = ""
+  s.summary     = %q{Create simple Torquebox.yml templates for your Torquebox, Rack-based applications.}
+  s.description = %q{Torquebox (http://www.torquebox.org) is a JBoss Application Server that will run your
+  Rack and Rails apps in JRuby.  Torquebox provides a number of additional functionality that you might find useful, such
+  as messaging, background services, and scheduled tasks.  Configuring those is incredibly easy, since they all rely on
+  simple YAML file configs.  This CLI application simplifies that further by lettnig you generate your applications and
+  application templates with simple command line executions.}
+
+  s.add_development_dependency "rspec"
+  s.add_development_dependency "sinatra"
+  s.add_dependency "thor"
+
+  s.executables << "tb"
+
+  s.rubyforge_project = "tb-cli"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+end

metadata

@@ -0,0 +1,116 @@
+--- !ruby/object:Gem::Specification 
+name: tb-cli
+version: !ruby/object:Gem::Version 
+  prerelease: 
+  version: 0.1.0
+platform: ruby
+authors: 
+- Nick Klauer
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-05-29 00:00:00 -05:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :development
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: sinatra
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :development
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: thor
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :runtime
+  version_requirements: *id003
+description: |-
+  Torquebox (http://www.torquebox.org) is a JBoss Application Server that will run your
+    Rack and Rails apps in JRuby.  Torquebox provides a number of additional functionality that you might find useful, such
+    as messaging, background services, and scheduled tasks.  Configuring those is incredibly easy, since they all rely on
+    simple YAML file configs.  This CLI application simplifies that further by lettnig you generate your applications and
+    application templates with simple command line executions.
+email: 
+- klauer@gmail.com
+executables: 
+- tb
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- .yardopts
+- Gemfile
+- README.md
+- Rakefile
+- bin/tb
+- lib/tb-cli.rb
+- lib/tb-cli/camel_case.rb
+- lib/tb-cli/cli/add.rb
+- lib/tb-cli/cli/rack.rb
+- lib/tb-cli/config_file.rb
+- lib/tb-cli/descriptions.rb
+- lib/tb-cli/templates/Gemfile.tt
+- lib/tb-cli/templates/README.tt
+- lib/tb-cli/templates/Rakefile.tt
+- lib/tb-cli/templates/app.rb.tt
+- lib/tb-cli/templates/config.ru.tt
+- lib/tb-cli/templates/fully-exploded-torquebox.yml.tt
+- lib/tb-cli/templates/template.rb
+- lib/tb-cli/templates/torquebox.yml.tt
+- lib/tb-cli/version.rb
+- spec/spec_helper.rb
+- tb-cli.gemspec
+has_rdoc: true
+homepage: ""
+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: tb-cli
+rubygems_version: 1.6.1
+signing_key: 
+specification_version: 3
+summary: Create simple Torquebox.yml templates for your Torquebox, Rack-based applications.
+test_files: 
+- spec/spec_helper.rb