xing-framework 0.0.1 → 0.0.2

data/default_configuration/base_app/lib/capistrano/tasks/sidekiq.rake

@@ -0,0 +1,218 @@
+# vim: set ft=ruby :
+#
+namespace :load do
+  task :defaults do
+    set :sidekiq_default_hooks, -> { true }
+
+    set :sidekiq_path, -> { release_path }
+    set :sidekiq_pid, -> { File.join(shared_path, 'tmp', 'pids', 'sidekiq.pid') }
+    set :sidekiq_env, -> { fetch(:rack_env, fetch(:rails_env, fetch(:stage))) }
+    set :sidekiq_log, -> { File.join(shared_path, 'log', 'sidekiq.log') }
+    set :sidekiq_timeout, -> { 10 }
+    set :sidekiq_role, -> { :app }
+    set :sidekiq_processes, -> { 1 }
+    # Rbenv and RVM integration
+    set :rbenv_map_bins, fetch(:rbenv_map_bins).to_a.concat(%w(sidekiq sidekiqctl))
+    set :rvm_map_bins, fetch(:rvm_map_bins).to_a.concat(%w(sidekiq sidekiqctl))
+  end
+end
+
+namespace :deploy do
+  before :starting, :check_sidekiq_hooks do
+    invoke 'sidekiq:add_default_hooks' if fetch(:sidekiq_default_hooks)
+  end
+  after :publishing, :restart_sidekiq do
+    invoke 'sidekiq:restart' if fetch(:sidekiq_default_hooks)
+  end
+end
+
+namespace :sidekiq do
+  def for_each_process(reverse = false, &block)
+    pids = processes_pids
+    pids.reverse! if reverse
+    pids.each_with_index do |pid_file, idx|
+      p fetch(:sidekiq_path)
+      within fetch(:sidekiq_path) do
+        yield(pid_file, idx)
+      end
+    end
+  end
+
+  def processes_pids
+    pids = []
+    fetch(:sidekiq_processes).times do |idx|
+      pids.push (idx.zero? && fetch(:sidekiq_processes) <= 1) ?
+                    fetch(:sidekiq_pid) :
+                    fetch(:sidekiq_pid).gsub(/\.pid$/, "-#{idx}.pid")
+
+    end
+    pids
+  end
+
+  def pid_process_exists?(pid_file)
+    pid_file_exists?(pid_file) and test(*("kill -0 $( cat #{pid_file} )").split(' '))
+  end
+
+  def pid_file_exists?(pid_file)
+    test(*("[ -f #{pid_file} ]").split(' '))
+  end
+
+  def stop_sidekiq(pid_file)
+    if fetch(:stop_sidekiq_in_background, fetch(:sidekiq_run_in_background))
+      if fetch(:sidekiq_use_signals)
+        background "kill -TERM `cat #{pid_file}`"
+      else
+        background :bundle, :exec, :sidekiqctl, 'stop', "#{pid_file}", fetch(:sidekiq_timeout)
+      end
+    else
+      execute :bundle, :exec, :sidekiqctl, 'stop', "#{pid_file}", fetch(:sidekiq_timeout)
+    end
+  end
+
+  def quiet_sidekiq(pid_file)
+    if fetch(:sidekiq_use_signals)
+      background "kill -USR1 `cat #{pid_file}`"
+    else
+      begin
+        execute :bundle, :exec, :sidekiqctl, 'quiet', "#{pid_file}"
+      rescue SSHKit::Command::Failed
+        # If gems are not installed eq(first deploy) and sidekiq_default_hooks as active
+        warn 'sidekiqctl not found (ignore if this is the first deploy)'
+      end
+    end
+  end
+
+  def start_sidekiq(pid_file, idx = 0)
+    args = []
+    args.push "--index #{idx}"
+    args.push "--pidfile #{pid_file}"
+    args.push "--environment #{fetch(:sidekiq_env)}"
+    args.push "--logfile #{fetch(:sidekiq_log)}" if fetch(:sidekiq_log)
+    args.push "--require #{fetch(:sidekiq_require)}" if fetch(:sidekiq_require)
+    args.push "--tag #{fetch(:sidekiq_tag)}" if fetch(:sidekiq_tag)
+    Array(fetch(:sidekiq_queue)).each do |queue|
+      args.push "--queue #{queue}"
+    end
+    args.push "--config #{fetch(:sidekiq_config)}" if fetch(:sidekiq_config)
+    args.push "--concurrency #{fetch(:sidekiq_concurrency)}" if fetch(:sidekiq_concurrency)
+    # use sidekiq_options for special options
+    args.push fetch(:sidekiq_options) if fetch(:sidekiq_options)
+
+    if defined?(JRUBY_VERSION)
+      args.push '>/dev/null 2>&1 &'
+      warn 'Since JRuby doesn\'t support Process.daemon, Sidekiq will not be running as a daemon.'
+    else
+      args.push '--daemon'
+    end
+
+    if fetch(:start_sidekiq_in_background, fetch(:sidekiq_run_in_background))
+      background :bundle, :exec, :sidekiq, args.compact.join(' ')
+    else
+      execute :bundle, :exec, :sidekiq, args.compact.join(' ')
+    end
+  end
+
+  task :add_default_hooks do
+    after 'deploy:starting', 'sidekiq:quiet'
+    after 'deploy:updated', 'sidekiq:stop'
+    after 'deploy:reverted', 'sidekiq:stop'
+    after 'deploy:published', 'sidekiq:start'
+  end
+
+  desc 'Quiet sidekiq (stop processing new tasks)'
+  task :quiet do
+    on roles fetch(:sidekiq_role) do
+      if test("[ -d #{release_path} ]") # fixes #11
+        for_each_process(true) do |pid_file, idx|
+          if pid_process_exists?(pid_file)
+            quiet_sidekiq(pid_file)
+          end
+        end
+      end
+    end
+  end
+
+  desc 'Stop sidekiq'
+  task :stop do
+    on roles fetch(:sidekiq_role) do
+      if test("[ -d #{release_path} ]")
+        for_each_process(true) do |pid_file, idx|
+          if pid_process_exists?(pid_file)
+            stop_sidekiq(pid_file)
+          end
+        end
+      end
+    end
+  end
+
+  desc 'Start sidekiq'
+  task :start do
+    on roles fetch(:sidekiq_role) do
+      for_each_process do |pid_file, idx|
+        start_sidekiq(pid_file, idx) unless pid_process_exists?(pid_file)
+      end
+    end
+  end
+
+  desc 'Restart sidekiq'
+  task :restart do
+    invoke 'sidekiq:stop'
+    invoke 'sidekiq:start'
+  end
+
+  desc 'Rolling-restart sidekiq'
+  task :rolling_restart do
+    on roles fetch(:sidekiq_role) do
+      for_each_process(true) do |pid_file, idx|
+        if pid_process_exists?(pid_file)
+          stop_sidekiq(pid_file)
+        end
+        start_sidekiq(pid_file, idx)
+      end
+    end
+  end
+
+  # Delete any pid file not in use
+  task :cleanup do
+    on roles fetch(:sidekiq_role) do
+      for_each_process do |pid_file, idx|
+        if pid_file_exists?(pid_file)
+          execute "rm #{pid_file}" unless pid_process_exists?(pid_file)
+        end
+      end
+    end
+  end
+
+  # TODO : Don't start if all proccess are off, raise warning.
+  desc 'Respawn missing sidekiq proccesses'
+  task :respawn do
+    invoke 'sidekiq:cleanup'
+    on roles fetch(:sidekiq_role) do
+      for_each_process do |pid_file, idx|
+        unless pid_file_exists?(pid_file)
+          start_sidekiq(pid_file, idx)
+        end
+      end
+    end
+  end
+
+  def template_sidekiq(from, to, role)
+    [
+        File.join('lib', 'capistrano', 'templates', "#{from}-#{role.hostname}-#{fetch(:stage)}.rb"),
+        File.join('lib', 'capistrano', 'templates', "#{from}-#{role.hostname}.rb"),
+        File.join('lib', 'capistrano', 'templates', "#{from}-#{fetch(:stage)}.rb"),
+        File.join('lib', 'capistrano', 'templates', "#{from}.rb.erb"),
+        File.join('lib', 'capistrano', 'templates', "#{from}.rb"),
+        File.join('lib', 'capistrano', 'templates', "#{from}.erb"),
+        File.expand_path("../../templates/#{from}.rb.erb", __FILE__),
+        File.expand_path("../../templates/#{from}.erb", __FILE__)
+    ].each do |path|
+      if File.file?(path)
+        erb = File.read(path)
+        upload! StringIO.new(ERB.new(erb).result(binding)), to
+        break
+      end
+    end
+  end
+
+end

data/default_configuration/base_app/static-app.ru

@@ -0,0 +1,3 @@
+$:.unshift("./backend")
+require 'lib/static-app'
+run LrdCms2::StaticApp.build("frontend/bin", ENV['LRD_BACKEND_PORT'])

data/default_configuration/base_app/tmux-windows

@@ -0,0 +1,68 @@
+#!/bin/bash -e
+
+#TODO: port needs to actually do the port addition e.g. -p 1 => +1 to port numbers
+
+existing="yes"
+new_thing="pane"
+port=0
+extra_config=~/.lrd-dev-tmux.conf
+
+if [ -z $TMUX ]; then
+  existing="no"
+fi
+
+if tmux list-windows -F '#{window_name}' | egrep 'Dev Servers|Grunt Watch|Backend Server|Sidekiq'; then
+  echo "It looks like there are already windows open for this tmux?"
+  exit 2
+fi
+
+while getopts Pw option; do
+  case $option in
+    P) new_thing="pane";;
+  w) new_thing="window";;
+
+esac
+done
+
+DEPENDENCIES_INCLUDE_TMUX=true rake preflight || exit 1
+
+frontend_dir=$(realpath frontend)
+backend_dir=$(realpath backend)
+
+case $new_thing in
+  pane)
+    if [ $existing == "yes" ]; then
+      tmux new-window -n "Dev Servers" -c $frontend_dir 'bundle exec node_modules/.bin/grunt --stack watch:develop' \; set-window-option remain-on-exit on
+    else
+      tmux new-session -d -n "Dev Servers" -c $frontend_dir 'bundle exec node_modules/.bin/grunt --stack watch:develop' \; set-window-option remain-on-exit on
+    fi
+
+    tmux split-window -c $backend_dir 'bundle exec sidekiq'
+    tmux split-window -c $backend_dir 'bundle exec rails server'
+
+    tmux select-layout -t "Dev Servers" tiled
+    ;;
+  window)
+    if [ $existing == "yes" ]; then
+      tmux new-window -c $frontend_dir -n "Grunt Watch" 'env; bundle exec node_modules/.bin/grunt watch:develop' \; set-window-option remain-on-exit on
+    else
+      tmux new-session -d -c $frontend_dir -n "Grunt Watch" 'env; bundle exec node_modules/.bin/grunt watch:develop' \; set-window-option remain-on-exit on
+    fi
+
+    tmux new-window -c $backend_dir -n "Backend Server" 'bundle exec rails server' \; set-window-option remain-on-exit on
+
+    tmux new-window -c $backend_dir -n "Sidekiq" 'bundle exec sidekiq' \; set-window-option remain-on-exit on
+esac
+
+if [ -f $extra_config ]; then
+  echo Loading $extra_config
+  tmux source-file $extra_config
+else
+  echo No $extra_config to load
+fi
+
+if [ $existing != "yes" ]; then
+  tmux attach-session -d
+fi
+
+rake develop:launch_browser

data/default_configuration/base_app/tmux-windows.txt

@@ -0,0 +1,53 @@
+A quick guide to tmux-windows:
+
+( "Help, I started tmux-windows and I can't get out!" Hit Ctrl-b, type
+kill-session, hit return )
+
+This is a script around the very excellent terminal multiplexer tmux. The
+script launches all the services that help develop web apps in the LRD
+framework.
+
+Start by running `./tmux-windows` - you'll see some output while it checks
+that things seem to be in order, and then it'll redraw the console into 3
+panes.
+
+- In one, you'll see a big Grunt task building the front end JavaScript.
+- In the next, you'll see Sidekiq handling background processes.
+- In the last, you'll see the Rails server handling requests.
+
+A browser window should open connected to the development server, so you can
+poke around at things as you work on it.
+
+Quickie on the default command and interactions:
+
+Tmux is meant to get out of the way while you do other things. As a result,
+you need to let it know that keystrokes are directed at it. By default, you
+prefix all your commands directed at tmux with Ctrl-b.
+
+Ctrl-b Up/Down/Left/Right will bounce around between panes.
+Ctrl-b : will open up a command line where you can enter commands for tmux
+  Useful examples include
+  kill-session (when you're done)
+  respawn-pane (if one of the services crashes - Tmux will add the message
+    "Pane is dead")
+  respawn-window -k (restart everything)
+
+Ctrl-b [ enters copy mode which merits its own section
+
+Copy Mode:
+You can copy and paste stuff using just the keyboard here, but the most useful
+commands are these:
+You can use PageUp/PageDown and the arrow keys to browse the backlog.
+
+? to search - type a few characters, hit return.
+n to search up for the next occurance.
+N to search down for the next occrance.
+(the search commands are brought in from less, if they look familiar)
+
+q will end copy mode and go back to the bottom of the console, where the
+  service will still be running
+
+
+Finally, there's an example-lrd-dev-tmux.conf file that you can copy to your
+home directory to make thing a little easier. Review it first, if only to find
+out where to put it! :)

data/lib/xing/cli.rb

@@ -1,5 +1,3 @@
-require 'byebug'
-
 module Xing
   class CLI
     SUPPORTED_VERBS = %w{new}
@@ -38,12 +36,19 @@ Global Options:
       when 'new'
         opts = Trollop::options do
           opt :cms, "Include content management architecture. (coming soon)"
+          opt :ruby_version, "Set the ruby version used for the new project (e.g. 2.2)", :type => :string
           stop_on ['name']
         end
         name = ARGV.shift
         Trollop::die "Please specify a project name with 'xing new <name>'" unless name
         Trollop::die "The CMS option is not yet implemented." if opts[:cms]
-        Xing::CLI::Generators::NewProject.new.generate(opts.merge({:name => name}))
+        if opts[:ruby_version].nil?
+          opts[:ruby_version] = RbConfig::CONFIG.values_at("MAJOR","MINOR").join(".")
+        end
+        generator = Xing::CLI::Generators::NewProject.new
+        generator.target_name = name
+        generator.ruby_version = opts[:ruby_version]
+        generator.generate
       else
         Trollop::die "Unknown command.  Supported commands are [" + SUPPORTED_VERBS.join(" ") + "]"
       end

data/lib/xing/cli/generators/new_project.rb

@@ -4,26 +4,61 @@ module Xing::CLI::Generators
   class NewProject
     include Caliph::CommandLineDSL
 
-    BASE_PROJECT_URL = "git@github.com:XingFramework/xing-application-base.git"
+    attr_accessor :target_name
+    attr_accessor :ruby_version
 
-    # For the moment, this is the simplest thing that can work. Zero templating is done
-    # so the project will still have the default module names etc.
-    def generate(options)
-      shell = Caliph.new()
-      command = cmd('git', 'clone', '--depth=1', '--branch=master', BASE_PROJECT_URL, options[:name])
+    def shell
+      @shell ||= Caliph.new
+    end
+    attr_writer :shell
+
+    # For the moment, this is the simplest thing that can work. Zero templating
+    # is done so the project will still have the default module names etc.
+    def generate
+      command = cmd('cp', '-a', File.expand_path('../../../../../default_configuration/base_app/', __FILE__), target_name)
       result = shell.run(command)
 
-      if result.succeeded?
-        remove_git_directory(options[:name], shell)
+      unless result.succeeded?
+        raise "Attempt to copy base application to #{target_name} failed!"
+      end
+
+      write_ruby_version
+      write_ruby_version "frontend"
+      write_ruby_version "backend"
+
+      with_temporary_database_yml do
+        Bundler.with_clean_env do
+          shell.run(cmd("cd", target_name) &
+                    cmd("bundle", "install")).must_succeed!
+
+          shell.run(cmd("cd", File.join(target_name, "frontend")) &
+                    cmd("bundle", "install") &
+                    cmd("npm", "install")).must_succeed!
+
+          shell.run(cmd("cd", File.join(target_name, "backend")) &
+                    cmd("bundle", "install") &
+                    cmd("rake", "xing:install:migrations")).must_succeed!
+        end
+      end
+    end
+
+    def with_temporary_database_yml
+      dbyml_path = File.join(target_name, "backend", "config", "database.yml")
+      if File.exist?(dbyml_path)
+        yield
       else
-        raise "Attempt to clone base git repository failed!"
+        begin
+          File.open(dbyml_path, "w"){}
+          yield
+        ensure
+          File.unlink(dbyml_path)
+        end
       end
     end
 
-    def remove_git_directory(name, shell)
-      git_dir = File.join("#{name}", ".git")
-      if File.exists?(git_dir)
-        shell.run(cmd('rm -rf', git_dir))
+    def write_ruby_version(*subdir)
+      File.open(File.join(*([target_name] + subdir + [".ruby-version"])), "w") do |rv|
+        rv.write(ruby_version)
       end
     end
   end