appli 0.0.12 → 2.0.0

data/lib/appli/deploy.rb

@@ -0,0 +1,144 @@
+Capistrano::Configuration.instance(:must_exist).load do
+  
+  default_run_options[:pty] = true
+  
+  ## Define the default roles
+  role :app
+  
+  ## Set the default configuration
+  set :user, "deploy"
+  set :ssh_options, {:forward_agent => true, :port => 22}
+  set :environment, "production"
+  set :branch, "master"
+  
+  namespace :setup do
+  
+    desc 'Initialises the application on your server(s)'
+    task :default do
+      
+      unless ENV['DBPASS']
+        puts "\n    \e[31mAn error occurred while setting up your remote repository:\n\n"
+        puts "    You must pass DBPASS to this task. This should be the database password for the database"
+        puts "    with the name '#{database_user}' on #{database_host}.\e[0m\n\n"
+        
+        next
+      end
+    
+      ## Clear anything out the way of the application
+      run "rm -Rf #{deploy_to}"
+    
+      ## Clone the repository into the folder
+      run "git clone -n #{repository} #{deploy_to} --branch #{branch} --quiet"
+
+      ## Create a rollback branch, create a new branch called 'deploy' and remove the 
+      ## origin branch
+      run "cd #{deploy_to} && git branch rollback && git checkout -b deploy && git branch -d #{branch}"
+    
+      ## Upload the database configuration
+      add_db_config
+      
+      ## Finalize
+      deploy.finalise
+    end
+    
+    desc 'Initialises the application (including the database schema)'
+    task :full do
+      puts
+      puts "    \e[36mPotentially dangerous action - read this carefully:\e[0m"
+      puts "    This task will clear your database (#{database_name}) when it has completed setting"
+      puts "    up the remote repository. We will wait 15 seconds for you to change your mind. Press"
+      puts "    CTRL+C to cancel this task now."
+      puts
+      sleep 15
+      
+      default
+      load_schema
+      deploy.start
+      
+      puts
+      puts "    \e[32mYour application has now been set up for the first time\e[0m"
+      puts
+    end
+
+    desc 'Upload a database configuration using the variables you enter'
+    task :add_db_config, :roles => [:app] do
+      next unless fetch(:database_host, nil)
+      configuration = Array.new.tap do |a|
+        a << "#{environment}:"
+        a << "  adapter: mysql2"
+        a << "  encoding: utf8"
+        a << "  reconnect: true"
+        a << "  host: #{database_host}"
+        a << "  database: #{database_name}"
+        a << "  username: #{database_user}"
+        a << "  password: #{ENV['DBPASS'] || 'xxxxx'}"
+        a << "  pool: 5\n"
+      end.join("\n")
+      put configuration, "#{deploy_to}/config/database.yml"
+    end
+    
+    desc 'Load the schema'
+    task :load_schema, :roles => [:app], :only => {:database_ops => true} do
+      run "cd #{deploy_to} && RAILS_ENV=#{environment} bundle exec rake db:schema:load"
+    end
+  end
+  
+  namespace :deploy do
+    desc 'Deploy your application'
+    task :default do
+      update_code
+      restart
+    end
+    
+    desc 'Deploy and run migrations'
+    task :migrations do
+      set :run_migrations, true
+      default
+    end
+    
+    
+    task :update_code do
+      run "cd #{deploy_to} && git branch -d rollback && git branch rollback"
+      run "cd #{deploy_to} && git fetch origin && git reset --hard origin/#{fetch(:branch)}"
+      finalise
+    end
+    
+    task :finalise do
+      execute = Array.new
+      execute << "cd #{deploy_to}"
+      execute << "git submodule init"
+      execute << "git submodule sync"
+      execute << "git submodule update --recursive"
+      run execute.join(' && ')
+
+      run "cd #{deploy_to} && bundle --deployment --quiet"
+      assets
+      migrate if fetch(:run_migrations, false)
+    end
+    
+    desc 'Run any database migrations'
+    task :migrate, :roles => [:app], :only => {:database_ops => true} do
+      run "cd #{deploy_to} && RAILS_ENV=#{environment} bundle exec rake db:migrate"
+    end
+    
+    task :assets, :roles => [:app] do
+      run "if [ -e #{deploy_to}/app/assets ] ; then cd #{deploy_to} && RAILS_ENV=#{environment} bundle exec rake assets:precompile ; fi"
+    end
+    
+    desc 'Reset the application'
+    task :restart, :roles => [:app] do
+      run "mkdir -p #{deploy_to}/tmp && touch #{deploy_to}/restart.txt"
+    end
+    
+    desc 'Start the application'
+    task :start, :roles => [:app] do
+      restart
+    end
+    
+    desc 'Stop the application'
+    task :stop, :roles => [:app] do
+      restart
+    end
+    
+  end
+end

metadata

@@ -1,75 +1,45 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: appli
-version: !ruby/object:Gem::Version 
-  version: 0.0.12
+version: !ruby/object:Gem::Version
+  version: 2.0.0
+  prerelease: 
 platform: ruby
-authors: 
+authors:
 - Adam Cooke
 autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2010-02-19 00:00:00 +00:00
-default_executable: 
-dependencies: 
-- !ruby/object:Gem::Dependency 
-  name: json
-  type: :runtime
-  version_requirement: 
-  version_requirements: !ruby/object:Gem::Requirement 
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        version: 1.1.5
-    version: 
+date: 2011-12-10 00:00:00.000000000Z
+dependencies: []
 description: 
 email: adam@atechmedia.com
-executables: 
-- appli
+executables: []
 extensions: []
-
 extra_rdoc_files: []
-
-files: 
-- bin/appli
-- lib/appli/command.rb
-- lib/appli.rb
-- lib/commands/apps.rb
-- lib/commands/cap.rb
-- lib/commands/db.rb
-- lib/commands/domains.rb
-- lib/commands/gems.rb
-- lib/commands/keys.rb
-- lib/commands/logs.rb
-- lib/commands/ssh.rb
-- lib/commands/stats.rb
-has_rdoc: true
-homepage: http://www.atechmedia.com
+files:
+- lib/appli/deploy.rb
+homepage: http://www.applihq.com
 licenses: []
-
 post_install_message: 
 rdoc_options: []
-
-require_paths: 
+require_paths:
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      version: "0"
-  version: 
-required_rubygems_version: !ruby/object:Gem::Requirement 
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      version: "0"
-  version: 
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
 requirements: []
-
 rubyforge_project: 
-rubygems_version: 1.3.5
+rubygems_version: 1.8.10
 signing_key: 
 specification_version: 3
-summary: Gem for Appli shared Ruby hosting management
+summary: Deployment Recipes for Appli
 test_files: []
-

data/bin/appli

@@ -1,3 +0,0 @@
-#!/usr/bin/env ruby
-require File.dirname(__FILE__) + "/../lib/appli"
-Appli.run(ARGV.shift, ARGV)

data/lib/appli/command.rb

@@ -1,144 +0,0 @@
-module Appli
-  class Command
-    
-    def initialize(block)
-      (class << self;self end).send :define_method, :command, &block
-    end
-    
-    def debug?
-      false
-    end
-    
-    def call(options, *args)
-      @options = options
-      arity = method(:command).arity
-      args << nil while args.size < arity
-      send :command, *args
-    rescue Error => e
-      puts "An error occured while excuting your command...\n#{e.message}"
-    end
-    
-    private
-    
-    def host
-      application['host']
-    end
-    
-    def application
-      return nil if @options[:application].nil?
-      @application ||= get("applications/#{@options[:application]}")['application']
-    rescue
-      puts "Application not found with identifier '#{@options[:application]}'"
-      Process.exit(1)
-    end
-    
-    def options
-      @options || Hash.new
-    end
-
-    def git_config_variable(name)
-      @config_variables = Hash.new if @config_variables.nil?
-      if @config_variables[name]
-        @config_variables[name]
-      else
-        r = `git config appli.#{name.to_s}`.chomp
-        puts "Getting configuration variable: appli.#{name.to_s} (was: '#{r}')" if debug?
-        @config_variables[name] = (r.empty? ? nil : r)
-      end
-    end
-    
-    def api_request(url, username, password, data = nil, method = nil)
-      require 'uri'
-      require 'net/http'
-      require 'net/https'
-      uri = URI.parse(url)
-      
-      if method.nil?
-        method = (data ? :post : :get)
-      end
-            
-      req = case method
-      when :post
-        Net::HTTP::Post.new(uri.path)
-      when :delete
-        Net::HTTP::Delete.new(uri.path)
-      when :put
-        Net::HTTP::Put.new(uri.path)
-      else
-        Net::HTTP::Get.new(uri.path)
-      end
-
-      req.basic_auth(username, password)
-      req.add_field("Accept", "application/json")
-      req.add_field("Content-type", "application/json")
-      res = Net::HTTP.new(uri.host, uri.port)
-      if url.include?('https://')
-        res.use_ssl = true
-        res.verify_mode = OpenSSL::SSL::VERIFY_NONE
-      end
-      puts "Requesting '#{url}' on as #{method.to_s.upcase}" if debug?
-      res = res.request(req, data)
-      case res
-      when Net::HTTPSuccess
-        return res.body
-      when Net::HTTPNotFound
-        puts "Resource not found"
-        Process.exit(1)
-      when Net::HTTPServiceUnavailable
-        puts "The API is currently unavailable. Please check your codebase account has been enabled for API access."
-        Process.exit(1)
-      when Net::HTTPForbidden, Net::HTTPUnauthorized, Net::HTTPFound
-        puts "\e[41;37mAccess Denied. Check your appli username & API key have been configured correctly.\e[0m"
-        Process.exit(1)
-      else
-        @errors = res.body
-        return false
-      end
-    end
-    
-    def errors
-      @errors || nil
-    end
-    
-    def get(path)
-      JSON.parse(api(path))
-    end
-    
-    def api(path, data = nil, method = nil)
-      api_request("http://#{domain}/#{path}", git_config_variable(:username), git_config_variable(:apikey), data, method)
-    end
-    
-    def api_on_app(path, data = nil, method = nil)
-      api("applications/#{@options[:application]}/#{path}", data, method)
-    end
-    
-    def domain
-      git_config_variable(:domain) || 'applihq.com'
-    end
-        
-    def ssh(command, filter = //)
-      puts remote_exec(command).gsub(filter, '')
-    end
-    
-    def remote_exec(command)
-      command = "ssh -p #{application['ssh_port']} app@#{host['name']} \"#{command}\""
-      puts "Executing: #{command}" if debug?
-      `#{command}`
-    end
-    
-    def ssh_exec(command)
-      exec("ssh -p #{application['ssh_port']} app@#{host['name']} \"#{command}\"")
-    end
-        
-    def error(command, exit_code = 1)
-      $stderr.puts command
-      Process.exit(exit_code)
-    end
-    
-    def display_errors
-      for key, value in JSON.parse(errors)
-        puts " * #{key.capitalize} #{value}"
-      end
-    end
-  end
-end

data/lib/appli.rb

@@ -1,181 +0,0 @@
-$:.unshift File.dirname(__FILE__)
-
-require 'rubygems'
-require 'json'
-
-require 'appli/command'
-
-trap("INT") { puts; exit }
-
-module Appli
-  extend self
-  
-  class Error < RuntimeError; end
-  class NotConfiguredError < StandardError; end
-  class MustBeInRepositoryError < StandardError; end
-  
-  VERSION = "0.0.12"
-  
-  def run(command, args = [])
-    load_commands
-    command = 'help' if command.nil?
-    
-    if @global_commands[command]
-      run_command(command, :global, args)
-    elsif @application_commands[args.first]
-      run_command(args.shift, :app, ([command] + args))
-    else
-      puts "usage: appli [command]"
-      puts "Command not found. Check 'appli help' for full information."
-      Process.exit(1)
-    end  
-  end
-  
-  def run_command(command, type, args = [])
-    array = (type == :global ? @global_commands : @application_commands)
-    
-    options = parse_options(args)    
-    options.merge!({:application => args.shift}) if type == :app
-
-    if args.size < array[command][:required_args].to_i
-      puts "error: #{array[command][:usage]}"
-      puts "See 'cb help #{command}' for usage."
-      Process.exit(1)
-    end
-
-    array[command][:block].call(options, *args)
-  end
-  
-  def command(command, options = {}, &block)
-    hash = Hash.new
-    hash[:description] = @next_description
-    hash[:usage] = @next_usage
-    hash[:flags] = @next_flags
-    hash[:required_args] = (options[:required_args] || 0)
-    hash[:block] = Command.new(block)
-    
-    @global_commands = Hash.new if @global_commands.nil?
-    @application_commands = Hash.new if @application_commands.nil?
-    
-    if options[:global]  
-      @global_commands[command] = hash
-    else      
-      @application_commands[command] = hash
-    end
-    
-    @next_usage, @next_description, @next_flags = nil, nil, nil
-  end
-  
-  def global_commands
-    @global_commands
-  end
-  
-  def application_commands
-    @application_commands
-  end
-  
-  def commands
-    global_commands.merge(application_commands)
-  end
-  
-  def desc(value)
-    @next_description = Array.new if @next_description.nil?
-    @next_description << value
-  end
-  
-  def usage(value)
-    @next_usage = value
-  end
-  
-  def flags(key, value)
-    @next_flags = Hash.new if @next_flags.nil?
-    @next_flags[key] = value
-  end
-  
-  def alias(a, b)
-    @aliases = Hash.new if @aliases.nil?
-    @aliases[a] = b
-  end
-  
-  def load_commands
-    Dir[File.join(File.dirname(__FILE__), 'commands', '*.rb')].each do |path|
-      Appli.module_eval File.read(path), path
-    end
-  end
-  
-  def parse_options(args)
-    idx = 0
-    args.clone.inject({}) do |memo, arg|
-      case arg
-      when /^--(.+?)=(.*)/
-        args.delete_at(idx)
-        memo.merge($1.to_sym => $2)
-      when /^--(.+)/
-        args.delete_at(idx)
-        memo.merge($1.to_sym => true)
-      when "--"
-        args.delete_at(idx)
-        return memo
-      else
-        idx += 1
-        memo
-      end
-    end
-  end
-end
-
-Appli.desc "Displays this help message"
-Appli.usage "cb help [command]"
-Appli.command "help", :global => true do |command|
-  if command.nil?
-    puts "The Appli Gem allows you to easily access your Appli account functions from the"
-    puts "command line. The functions below outline the options which are currently"
-    puts "available."
-    puts   
-    puts "\e[31mGlobal Commands\e[0m"
-    puts "-" * 80
-    puts 
-    for key, command in Appli.global_commands.sort_by{|k,v| k}
-      puts "   \e[36m#{key.rjust(15)}\e[0m  #{command[:description].first}"
-    end
-    puts
-    puts "\e[31mApplication Specific Commands\e[0m"
-    puts "-" * 80
-    
-    puts "The following commands can be executed by running 'appli [identifier] {command}'"
-    puts 
-    for key, command in Appli.application_commands.sort_by{|k,v| k}
-      description = command[:description].first
-      description = description[0,55] + '...' if description.size > 55
-      puts "   \e[36m#{key.rjust(15)}\e[0m  #{description}"
-    end
-    
-    puts
-    puts "For more information see http://www.applihq.com/gem"
-    puts "See 'appli help [command]' for usage information."
-  else
-    if c = Appli.commands[command]
-      puts c[:description]
-      if c[:usage]
-        puts
-        puts "Usage:"
-        puts "     #{c[:usage]}"
-      end
-      if c[:flags]
-        puts
-        puts "Options:"
-        for key, value in c[:flags]
-          puts "     #{key.ljust(15)} #{value}"
-        end
-      end
-    else
-      puts "Command Not Found. Check 'appli help' for a full list of commands available to you."
-    end
-  end
-end
-
-Appli.desc "Displays the current version number"
-Appli.usage "cb version"
-Appli.command "version", :global => true do
-  puts "Appli Gem Version #{Appli::VERSION}"
-end

data/lib/commands/apps.rb

@@ -1,55 +0,0 @@
-desc 'Display a list of all applications which you have access to'
-usage "appli list"
-command "list", :global => true do
-  apps = get("applications")
-  
-  hash = [[:name, "Name", 30], [:identifier , "Identifier", 30], [:ssh_port, "SSH Port", 12], [:host, "Host", 30]]
-  total = hash.inject(0) {|e,r| e + r.last}
-  puts "-" * total
-  for item in hash
-    key, value, chars = item
-    print value.to_s.ljust(chars)
-  end
-  puts
-  puts "-" * total
-  for app in apps.sort_by {|a| a['application']['name'].upcase }
-    for item in hash
-      key, value, chars = item
-      data = case key
-      when :host then app['application']['host']['name']
-      else
-        app['application'][key.to_s].to_s
-      end
-      print data.ljust(chars)
-    end
-    puts
-  end
-  puts "-" * total
-end
-
-desc "Create a new application with the provided identifier"
-usage "appli create {identifier}"
-command "create", :global => true, :required_args => 1 do |identifier|
-  puts "Creating new application with identifier '#{identifier}'. Please wait - this may take a few minutes."
-  result = api('applications', {:application => {:identifier => identifier, :name => identifier}}.to_json)
-  if errors
-    puts "\nAn error occured while creating your application:"
-    display_errors
-    puts
-    Process.exit(1)
-  else
-    application = JSON.parse(result)['application']
-    puts "\n\e[44;37mApplication has been built successfully and is now running on '#{application['host'] ? application['host']['name'] : 'unknown host'}'.\e[0m"
-    puts
-    puts "You can now use a number of commands to work with your application, see documentation at www.applihq.com for"
-    puts "full details. You can also manage the application using your web browser at the domain above."
-    puts
-    puts "You may be looking for one of the following commands:"
-    puts
-    puts "     * appli #{identifier} ssh"
-    puts "     * appli #{identifier} db:import"
-    puts "     * appli #{identifier} db:console"
-    puts "     * appli #{identifier} capify config/deploy.rb"
-    puts
-  end
-end

data/lib/commands/cap.rb

@@ -1,30 +0,0 @@
-desc 'Generates a pre-configured capistrano deployment recipe.'
-usage "appli [application] capify {export path}"
-command "capify", :required_args => 1 do |file|
-  contents = get("applications/#{@options[:application]}/capistrano")['config']
-  
-  ## Insert the Repository URL if we can...
-  repository_url = `git config remote.origin.url`
-  if $?.success?
-    contents.gsub!(/git\@\[...\]/, repository_url.chomp)
-  end
-  
-  ## Add the current branch name
-  branch_name = `git status > /dev/null 2>&1`.split("\n").first
-  if $?.success?
-    branch_name branch_name.split(/\s+/).last
-    contents.gsub!(/set \:branch, \"master\"/, "set :branch, \"#{branch_name.chomp}\"")
-  end
-  
-  ## Add any configuration files from your local config/ folder if you have one
-  if File.directory?('config')
-    config_files = Dir["config/*.yml"].map{|f| f.split('/').last }
-    contents.gsub!(/\%w\{ database\.yml \}/, "%w{ #{config_files.join(' ')} }")
-  end
-  
-  File.open(file, 'w') {|f| f.write(contents) }
-  puts "Generated capistrano deployment receipe at '#{file}'."
-  puts
-  puts "You should now edit this file to include the path to your repository. Along with any additional"
-  puts "configuration which may be required by your application."
-end

data/lib/commands/db.rb

@@ -1,82 +0,0 @@
-desc 'Create a MySQL console connection for your first database'
-usage "appli [application] mysql"
-command "db:console" do
-  database = get("applications/#{@options[:application]}/databases").first
-  if database
-    database = database['database']
-    puts "Connecting to database '#{database['name']}' on '#{database['host']['name']}'"
-    exec("ssh -t -p #{application['ssh_port']} app@#{host['name']} mysql -u #{database['username']} -p#{database['password']} -h #{database['host']['name']} #{database['name']}")
-  else
-    error("No database was not found for this application.")
-  end
-end
-
-desc 'Import a named MySQL file'
-usage "appli [application] db:import {database number} {path to import mysql dump}"
-command "db:import" do |number, path|  
-  error("Import file not found at '#{path}'") unless File.exist?(path)
-  database = get("applications/#{@options[:application]}/databases/#{number}")
-  if database
-    database = database['database']
-    puts "Uploading MySQL export to server..."
-    remote_exec("rm -f ~/.appli_import.sql")
-    system("scp -P #{application['ssh_port']} #{path} app@#{host['name']}:~/.appli_import.sql")
-    puts "Importing database into '#{database['name']}' on '#{database['host']['name']}'..."
-    remote_exec("mysql -u #{database['username']} -p#{database['password']} -h #{database['host']['name']} #{database['name']} < ~/.appli_import.sql")
-  else
-    error "No database was found with number '#{number}'"
-  end
-end
-
-desc 'List all databases on this application'
-usage "appli [application] db:lists"
-command "db:list" do
-  puts '-' * 80
-  print 'Name'.ljust(15)
-  print 'Username'.ljust(15)
-  print 'Password'.ljust(15)
-  print 'Host'.ljust(25)
-  puts
-  puts '-' * 80
-
-  for database in get("applications/#{@options[:application]}/databases")
-    database = database['database']
-    print database['name'].ljust(15)
-    print database['username'].ljust(15)
-    print database['password'].ljust(15)
-    print database['host']['name'].ljust(25)
-    puts
-  end
-end
-
-desc 'Create a new database with the entered label'
-usage 'appli [application] db:create {label}'
-command "db:create", :required_args => 1 do |*label|
-  label = label.join(' ')
-  if db = api_on_app('databases', {:database => {:label => label}}.to_json)
-    puts "Database has been created successfully. Connection details can be found below:"
-    db = JSON.parse(db)['database']
-    puts
-    puts "     Label.............: #{db['label']}"
-    puts "     Database Name.....: #{db['name']}"
-    puts "     Username..........: #{db['username']}"
-    puts "     Password..........: #{db['password']}"
-    puts "     Host..............: #{db['host']['name']}"
-    puts
-  else
-    puts "Database could not be created."
-    display_errors
-  end
-end
-
-desc 'Dump the database schema'
-usage "appli [application] db:export {db number} {file}"
-command "db:export", :required_args => 2 do |number, file|
-  if database = get("applications/#{@options[:application]}/databases/#{number}")['database']
-    dump = remote_exec("mysqldump -u #{database['username']} -p#{database['password']} -h #{database['host']['name']} #{database['name']}")
-    File.open(file, 'w') {|f| f.write(dump) }
-    puts "MySQL dump written to '#{file}'. It was #{dump.size} bytes"
-  else
-    error "Database not found with #{number}. Check 'appli [application] db:list'"
-  end
-end

data/lib/commands/domains.rb

@@ -1,40 +0,0 @@
-desc 'List all domains configured for this application'
-usage "appli [application] domains:list"
-command "domains:list" do 
-  domains = JSON.parse(api_on_app("domains"))
-  for domain in domains
-    extra = ''
-    extra = '(primary)' if domain['domain']['primary']
-    extra = '(redirect)' if domain['domain']['redirect']
-    puts " * #{domain['domain']['domain']} #{extra}"
-  end
-end
-
-desc "Add a new domain for this application"
-usage "appli [application] domains:add {domain} {options}"
-command "domains:add", :required_args => 1 do |name, options|
-  options = "" if options.nil?
-  if api_on_app("domains", {:domain => {:domain => name, :redirect => options.include?('redirect')}}.to_json)
-    puts "Domain '#{name}' added successfully."
-  else
-    puts "An error occured while adding your domain:"
-    display_errors
-  end
-end
-
-desc 'Remove a domain from this application'
-usage "appli [application] domains:remove {domain}"
-command "domains:remove", :required_args => 1 do |name|
-  domains = JSON.parse(api_on_app('domains'))
-  domain  = domains.select{|d| d['domain']['domain'] == name}.first
-  if domain
-    if api_on_app("domains/#{domain['domain']['id']}", nil, :delete)
-      puts "Domain ('#{name}') removed successfully"
-    else
-      error "Domain could not be removed at this time."
-    end
-  else
-    error "Domain ('#{name}') does not exist within this application"
-  end
-end
-

data/lib/commands/gems.rb

@@ -1,58 +0,0 @@
-class FakeGemfile
-  attr_reader :gems, :sources
-  
-  def initialize
-    @sources, @gems = [], []
-  end
-  
-  def gem(name, version = nil, options = {})
-    @gems << {:name => name, :version => version, :options => options}
-  end
-  
-  def method_missing(name, *values, &block)
-    yield block if block_given?
-  end
-end
-
-desc "Read in the specified Gemfile and install all the required gems on your application"
-usage "appli [application] gems:import {path to file}"
-command "gems:import" do |file|
-  file_to_import = File.expand_path(file || 'Gemfile')
-  unless File.exist?(file_to_import)
-    raise Error, "Gemfile was not found at #{file_to_import}"
-  end
-
-  puts "Importing gems from #{file_to_import}"
-  gem_details = FakeGemfile.new
-  gem_details.instance_eval(File.read(file_to_import), file_to_import)
-  
-  puts "There are #{gem_details.gems.size} gem(s) to install on your application."
-  for g in gem_details.gems[0,4]
-    puts "Installing #{g[:name]} (#{g[:version] || 'latest'})"
-    data = {:ruby_gem => {:name => g[:name], :version => g[:version]}}.to_json
-    if api_on_app "ruby_gems", data
-      puts "=> Installed successfully"
-    else
-      puts "=> Installation failed"
-    end
-  end
-end
-
-desc "Install the provided gem on your application's container"
-usage "appli [application] gems:install {gem name} {version]"
-command "gems:install", :required_args => 1 do |name, version|
-  puts "Installing #{name} (#{version || 'latest'})"
-  data = {:ruby_gem => {:name => name, :version => version || ''}}.to_json
-  if a = api_on_app("ruby_gems", data)
-    puts "=> Installed"
-  else
-    puts errors.inspect
-    puts "=> Install failed"
-  end
-end
-
-desc "List all installed gems for your application"
-usage "appli gems"
-command "gems" do
-  ssh "gem list"
-end

data/lib/commands/keys.rb

@@ -1,14 +0,0 @@
-desc "Upload your local public key to your appli user account"
-usage "appli keys:add {key file}"
-command "keys:add", :global => true do |file|
-  file = "#{ENV['HOME']}/.ssh/id_rsa.pub" if file.nil?
-  error("Key file not found at '#{file}'") unless File.file?(file)
-  key_data = File.read(file).chomp
-  data = {:key => {:key => key_data}}.to_json
-  if api("settings/keys", data)
-    puts "SSH key uploaded successfully from '#{file}'"
-  else
-    puts "Sorry, an error occured while adding your key. Please check the errors below:"
-    display_errors
-  end
-end

data/lib/commands/logs.rb

@@ -1,6 +0,0 @@
-desc "View a log file on the remote system locally"
-usage "appli [application] log {log file}"
-command "log" do |file|
-  file = "~/app/current/log/production.log" if file.nil?
-  ssh_exec "tail -f -n 200 #{file}"  
-end

data/lib/commands/ssh.rb

@@ -1,5 +0,0 @@
-desc 'Create an SSH connection to the application'
-usage "appli [application] ssh"
-command "ssh" do
-  exec "ssh -p #{application['ssh_port']} app@#{host['name']}"
-end

data/lib/commands/stats.rb

@@ -1,26 +0,0 @@
-desc "Display system memory usage"
-usage "appli mem:system"
-command "mem:system" do
-  puts remote_exec("free -m").split("\n")[0,2].join("\n")
-end
-
-desc 'Display passenger memory statistics'
-usage "appli mem:passenger"
-command "mem:passenger" do
-  ssh "passenger-memory-stats", /^\*\*\* WARNING\:(.*)$/
-end
-
-desc 'Display your current disk space usage'
-usage "appli diskusage"
-command "diskusage" do
-  output = remote_exec("df -h").split("\n")[1]
-  output = output.split(/\s+/)
-  fs, size, usage, available, usage_percent, mountpoint = output
-  puts "You are using #{usage} (including system files)."
-  puts
-  puts "You are not billed for system file usage - only files & gems which"
-  puts "you place within your hosting area."
-  puts
-  puts "Your system is limited to #{size} however if you need additional"
-  puts "space, please just contact support."
-end