ppane 0.1.0

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright © 2008-2010, Fingertips, http://www.fngtps.com,
+                       Eloy Duran <eloy@fngtps.com>,
+                       Thijs van der Vossen <thijs@fngtps.com>,
+                       Manfred Stienstra <manfred@fngtps.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/bin/ppane

@@ -0,0 +1,10 @@
+#!/usr/bin/env ruby
+
+if $0 == __FILE__
+  $:.unshift(File.expand_path('../../lib', __FILE__))
+end
+
+require 'passenger_pane'
+require 'option_parser'
+
+PassengerPane::Runner.run(*OptionParser.parse(ARGV))

data/lib/option_parser.rb

@@ -0,0 +1,28 @@
+class OptionParser
+  def self.parse(argv)
+    return [{},[]] if argv.empty?
+    
+    options  = {}
+    rest     = []
+    switch   = nil
+    
+    for value in argv
+      # values is a switch
+      if value[0] == 45
+        switch = value.slice((value[1] == 45 ? 2 : 1)..-1)
+        options[switch] = nil
+      else
+        if switch
+          # we encountered a switch so this
+          # value belongs  to  that  switch
+          options[switch] = value
+          switch = nil
+        else
+          rest << value
+        end
+      end
+    end
+    
+    [options, rest]
+  end
+end

data/lib/passenger_pane.rb

@@ -0,0 +1,7 @@
+module PassengerPane
+  autoload :Application,       'passenger_pane/application'
+  autoload :Configuration,     'passenger_pane/configuration'
+  autoload :DirectoryServices, 'passenger_pane/directory_services'
+  autoload :HttpdConf,         'passenger_pane/httpd_conf'
+  autoload :Runner,            'passenger_pane/runner'
+end

data/lib/passenger_pane/application.rb

@@ -0,0 +1,212 @@
+require 'fileutils'
+
+module PassengerPane
+  class Application
+    RAILS_APP_REGEXP = /::Initializer\.run|Application\.initialize!/
+    ATTRIBUTES = [:config_filename, :host, :aliases, :path, :framework, :environment, :vhost_address, :user_defined_data]
+    
+    def self.glob(configuration)
+      File.join(
+        configuration.apache_directory,
+        configuration.passenger_vhosts,
+        "*.#{configuration.passenger_vhosts_ext}"
+      )
+    end
+    
+    def self.all(configuration)
+      Dir.glob(glob(configuration)).map do |config_filename|
+        new(configuration, :config_filename => config_filename)
+      end
+    end
+    
+    def self.find(configuration, conditions={})
+      if conditions[:host]
+        all(configuration).detect do |app|
+          app.host == conditions[:host]
+        end
+      end
+    end
+    
+    attr_accessor *ATTRIBUTES
+    
+    def initialize(configuration, options={})
+      @configuration = configuration
+      set(options)
+      if options[:config_filename]
+        @new = false
+        _parse
+      elsif options[:path]
+        @new = true
+        _derive
+      else
+        raise ArgumentError, "Please specify either a :config_filename or :path"
+      end
+      @before_changes = to_hash
+    end
+    
+    def set(options)
+      options.each do |key, value|
+        setter = "#{key}="
+        send(setter, value) if respond_to?(setter)
+      end
+    end
+    
+    def new?
+      @new
+    end
+    
+    # -- Virtual Host reading and writing
+    
+    def contents
+      @contents ||= File.read(@config_filename)
+    end
+    
+    attr_writer :contents
+    
+    def _parse
+      data = contents.dup
+      
+      data.gsub!(/\n\s*ServerName\s+(.+)/, '')
+      @host = $1
+      
+      data.gsub!(/\n\s*ServerAlias\s+(.+)/, '')
+      @aliases = $1 || ''
+      
+      data.gsub!(/\n\s*DocumentRoot\s+"(.+)\/public"/, '')
+      @path = $1
+      
+      data.gsub!(/\n\s*(Rails|Rack)Env\s+(\w+)/, '')
+      @framework   = $1.downcase
+      @environment = $2
+      
+      data.gsub!(/<VirtualHost\s(.+?)>/, '')
+      @vhost_address = $1
+      
+      data.gsub!(/\s*<\/VirtualHost>\n*/, '').gsub!(/^\n*/, '')
+      @user_defined_data = data.strip
+    end
+    
+    def _document_root
+      File.join(@path, 'public')
+    end
+    
+    def _directory_defaults
+      %{
+  <Directory "#{_document_root}">
+    Order allow,deny
+    Allow from all
+  </Directory>
+      }.strip
+    end
+    
+    def _config_filename
+      File.join(
+        @configuration.apache_directory,
+        @configuration.passenger_vhosts,
+        "#{@host}.#{@configuration.passenger_vhosts_ext}"
+      )
+    end
+    
+    def _framework
+      environment_file = File.join(@path, 'config', 'environment.rb')
+      if File.exist?(environment_file) and File.read(environment_file) =~ RAILS_APP_REGEXP
+        'rails'
+      else
+        'rack'
+      end
+    end
+    
+    def _derive
+      @host ||= "#{File.basename(path).downcase.gsub('_','-')}.local"
+      @aliases ||= ''
+      @environment ||= 'development'
+      @vhost_address ||= '*:80'
+      @user_defined_data ||= _directory_defaults
+      @config_filename ||= _config_filename
+      @framework ||= _framework
+    end
+    
+    def rails?; @framework == 'rails' end
+    def rack?;  @framework == 'rack'  end
+    
+    def vhost_snippet
+      lines = []
+      lines << "<VirtualHost #{vhost_address}>"
+      lines << "  ServerName #{host}"
+      lines << "  ServerAlias #{aliases}" unless aliases == ''
+      lines << "  DocumentRoot \"#{_document_root}\""
+      lines << "  #{rails? ? 'RailsEnv' : 'RackEnv'} #{environment}"
+      lines << "  #{user_defined_data}" unless user_defined_data.strip == ''
+      lines << "</VirtualHost>"
+      lines.join("\n")
+    end
+    
+    def write
+      FileUtils.mkdir_p(File.dirname(@config_filename))
+      File.open(@config_filename, 'w') do |file|
+        file.write(vhost_snippet)
+      end; true
+    end
+    
+    # -- Dirty checking
+    
+    def to_hash
+      hash = { 'hosts' => [host, *aliases.split] }
+      ATTRIBUTES.each do |key|
+        hash[key.to_s] = instance_variable_get("@#{key}")
+      end; hash
+    end
+    
+    def changed?
+      @before_changes != to_hash
+    end
+    
+    def added_hosts
+      to_hash['hosts'] - @before_changes['hosts']
+    end
+    
+    def removed_hosts
+      @before_changes['hosts'] - to_hash['hosts']
+    end
+    
+    # -- Directory services
+    
+    def register
+      PassengerPane::DirectoryServices.register(to_hash['hosts'])
+    end
+    
+    def unregister
+      PassengerPane::DirectoryServices.unregister(to_hash['hosts'])
+    end
+    
+    def sync_host_registration
+      if new?
+        register
+      else
+        PassengerPane::DirectoryServices.register(added_hosts) and
+        PassengerPane::DirectoryServices.unregister(removed_hosts)
+      end
+    end
+    
+    # -- Persisting
+    
+    def save
+      write and sync_host_registration
+    end
+    
+    def delete
+      FileUtils.rm_rf(config_filename)
+      unregister
+      true
+    end
+    
+    # -- Operational
+    
+    def restart
+      if File.exist?(@path)
+        FileUtils.mkdir_p(File.join(File.join(@path, 'tmp')))
+        FileUtils.touch(File.join(@path, 'tmp', 'restart.txt'))
+      end
+    end
+  end
+end

data/lib/passenger_pane/configuration.rb

@@ -0,0 +1,54 @@
+module PassengerPane
+  class Configuration
+    CONFIG_FILENAME  = '~/.passenger_pane.yml'
+    APACHE_DIRECTORY = '/private/etc/apache2'
+    
+    def self.defaults
+      {
+        :ruby_binary            => "/System/Library/Frameworks/Ruby.framework/Versions/Current/usr/bin/ruby",
+        :httpd_binary           => "/usr/sbin/httpd",
+        :httpd_conf             => "httpd.conf",
+        :passenger_vhosts       => "passenger_pane_vhosts",
+        :passenger_vhosts_ext   => "vhost.conf",
+        :apache_restart_command => "/bin/launchctl stop org.apache.httpd"
+      }
+    end
+    
+    def self.config_filename
+      File.expand_path(CONFIG_FILENAME)
+    end
+    
+    def self.auto
+      configuration = new
+      if File.exist?(config_filename)
+        configuration.set(YAML.load_file(config_filename))
+      end
+      configuration
+    end
+    
+    attr_accessor :apache_directory, *defaults.keys
+    
+    def initialize(apache_directory=APACHE_DIRECTORY)
+      self.apache_directory = apache_directory
+      set(self.class.defaults)
+    end
+    
+    def set(options)
+      options.each do |key, value|
+        begin
+          send("#{key}=", value)
+        rescue NoMethodError
+          raise ArgumentError, "There is no configuration named `#{key}', valid options are: #{self.class.defaults.keys.join(', ')} and apache_directory."
+        end
+      end
+    end
+    
+    def httpd
+      @httpd ||= PassengerPane::HttpdConf.new(self)
+    end
+    
+    def applications
+      PassengerPane::Application.all(self)
+    end
+  end
+end

data/lib/passenger_pane/directory_services.rb

@@ -0,0 +1,19 @@
+module PassengerPane
+  class DirectoryServices
+    def self.registered_hosts
+      `/usr/bin/dscl localhost -list /Local/Default/Hosts`.split("\n")
+    end
+    
+    def self.register(hosts)
+      hosts.each do |host|
+        system "/usr/bin/dscl localhost -create /Local/Default/Hosts/#{host} IPAddress 127.0.0.1"
+      end
+    end
+    
+    def self.unregister(hosts)
+      hosts.each do |host|
+        system "/usr/bin/dscl localhost -delete /Local/Default/Hosts/#{host}"
+      end
+    end
+  end
+end

data/lib/passenger_pane/httpd_conf.rb

@@ -0,0 +1,66 @@
+module PassengerPane
+  class HttpdConf
+    attr_accessor :filename
+    
+    def initialize(configuration)
+      @configuration = configuration
+      @filename      = File.expand_path(configuration.httpd_conf, configuration.apache_directory)
+    end
+    
+    def contents
+      @contents ||= File.read(@filename)
+    end
+    
+    attr_writer :contents
+    
+    def passenger_vhost_include
+      "Include #{@configuration.apache_directory}/#{@configuration.passenger_vhosts}/*.#{@configuration.passenger_vhosts_ext}"
+    end
+    
+    def passenger_configuration_snippet
+      %{
+# Added by the Passenger preference pane
+# Make sure to include the Passenger configuration (the LoadModule,
+# PassengerRoot, and PassengerRuby directives) before this section.
+<IfModule passenger_module>
+  NameVirtualHost *:80
+  <VirtualHost *:80>
+    ServerName _default_
+  </VirtualHost>
+  #{passenger_vhost_include}
+</IfModule>
+      }.strip
+    end
+    
+    def valid?
+      `#{@configuration.httpd_binary} -t 2>&1`.strip == 'Syntax OK'
+    end
+    
+    def restart
+      if valid?
+        system @configuration.apache_restart_command
+      else
+        puts "[!] Apache configuration is not valid, skipping Apache restart"
+      end
+    end
+    
+    def passenger_module_installed?
+      `#{@configuration.httpd_binary} -D DUMP_MODULES 2>&1`.include? 'passenger_module'
+    end
+    
+    def passenger_configured?
+      !!(contents =~ /Include.*#{@configuration.passenger_vhosts}/)
+    end
+    
+    def configure_passenger
+      self.contents << "\n\n"
+      self.contents << passenger_configuration_snippet
+    end
+    
+    def write
+      File.open(@filename, 'w') do |file|
+        file.write(contents)
+      end
+    end
+  end
+end

data/lib/passenger_pane/runner.rb

@@ -0,0 +1,191 @@
+require 'yaml'
+
+module PassengerPane
+  class Runner
+    def initialize(options)
+      @options       = options
+      @configuration = PassengerPane::Configuration.auto
+    end
+    
+    def machine_readable?
+      @options['machine_readable']
+    end
+    
+    def info
+      if machine_readable?
+        puts YAML.dump({
+          'passenger_module_installed' => @configuration.http.passenger_module_installed?,
+          'passenger_configured' => @configuration.httpd.passenger_configured?
+        })
+      else
+        puts "Apache directory:     #{@configuration.apache_directory}"
+        puts "Passenger installed:  #{@configuration.httpd.passenger_module_installed? ? 'yes' : 'no'}"
+        puts "Passenger configured: #{@configuration.httpd.passenger_configured? ? 'yes' : 'no'}"
+        puts "Registered hostnames:"
+        PassengerPane::DirectoryServices.registered_hosts.each do |host|
+          puts "  #{host}"
+        end
+      end
+    end
+    
+    def configure
+      unless @configuration.httpd.passenger_configured?
+        @configuration.httpd.configure_passenger
+        @configuration.httpd.write
+        @configuration.httpd.restart
+      end
+    end
+    
+    def add(directory)
+      options = @options.dup
+      options[:path] = File.expand_path(directory)
+      application = PassengerPane::Application.new(@configuration, options)
+      if application.save
+        @configuration.httpd.restart
+      end
+      if machine_readable?
+        puts YAML.dump(application.to_hash)
+      end
+    end
+    
+    def update(host)
+      if application = PassengerPane::Application.find(@configuration, :host => host)
+        application.set(@options)
+        if application.save
+          @configuration.httpd.restart
+        end
+        if machine_readable?
+          puts YAML.dump(application.to_hash)
+        end
+      end
+    end
+    
+    def delete(host)
+      if application = PassengerPane::Application.find(@configuration, :host => host)
+        application.delete
+        @configuration.httpd.restart
+      end
+    end
+    
+    def list
+      if machine_readable?
+        puts YAML.dump(@configuration.applications.map do |app|
+          app.to_hash
+        end)
+      else
+        @configuration.applications.each_with_index do |app, index|
+          puts unless index == 0
+          puts "#{app.host}"
+          puts "  Aliases:     #{app.aliases}"
+          puts "  Folder:      #{app.path}"
+          puts "  Environment: #{app.environment}"
+        end
+      end
+    end
+    
+    def restart(host)
+      if host and application = PassengerPane::Application.find(@configuration, :host => host)
+        application.restart
+      else
+        @configuration.httpd.restart
+      end
+    end
+    
+    def register
+      @configuration.applications.each do |app|
+        app.register
+      end
+    end
+    
+    def self.usage
+      puts "Usage: #{File.basename($0)} <command> [options]"
+      puts
+      puts "Commands:"
+      puts "  list:             List all configured applications"
+      puts "  register:         Register all configured hostnames with Directory Services*"
+      puts "  info:             Show information about the system"
+      puts "  configure:        Configure Apache for use with the Passenger Pane*"
+      puts "  add <directory>:  Add an application in a directory*"
+      puts "  update <host>:    Update an application*"
+      puts "  delete <host>:    Deletes an application*"
+      puts "  restart <host>:   Restart an application"
+      puts "  restart:          Restart Apache to pick up configuration changes*"
+      puts
+      puts "* requires root privileges"
+      puts
+      puts "Options:"
+      puts "  -h, --help:       Show this help text"
+      puts "  -m, --machine     Use machine readable output"
+      puts
+      puts "Attributes:"
+      puts "  --host:           Hostname for the application (ie. myapp.local)"
+      puts "  --aliases:        Aliases for the application (ie. assets.myapp.local)"
+      puts "  --path:           The folder with the application"
+      puts "  --environment:    The environment to run, usually development or production"
+      puts "  --framework:      The framework, either rack or rails"
+    end
+    
+    def self.run(flags, args)
+      options = {}
+      command = args.shift.to_s
+      
+      return usage if command == ''
+      
+      flags.each do |name, value|
+        case name
+        when 'h', 'help'
+          command = 'help'
+        when 'm', 'machine'
+          options['machine_readable'] = true
+        else
+          options[name] = value
+        end
+      end
+      
+      unless $stdin.tty?
+        data = YAML.load($stdin.read) 
+        data.each do |name, value|
+          options[name] = value
+        end if data
+      end
+      
+      case command
+      when 'info'
+        new(options).info
+      when 'configure'
+        needs_root
+        new(options).configure
+      when 'add'
+        needs_root
+        new(options).add(args.first)
+      when 'update'
+        needs_root
+        new(options).update(args.first)
+      when 'delete'
+        needs_root
+        new(options).delete(args.first)
+      when 'restart'
+        host = args.first
+        needs_root unless host
+        new(options).restart(host)
+      when 'list'
+        new(options).list
+      when 'register'
+        needs_root
+        new(options).register
+      else
+        path = File.expand_path(command)
+        if File.exist?(path)
+          needs_root
+          new(options).add(path)
+        else
+          usage
+        end
+      end
+    end
+    
+    def self.needs_root
+      puts "[!] The command might not run because it requires root privileges" unless ENV['USER'] == 'root'
+    end
+  end
+end

metadata

@@ -0,0 +1,78 @@
+--- !ruby/object:Gem::Specification 
+name: ppane
+version: !ruby/object:Gem::Version 
+  hash: 27
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- Eloy Duran
+- Manfred Stienstra
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-12-14 00:00:00 +01:00
+default_executable: 
+dependencies: []
+
+description: "    The Passenger Pane is a preference pane on Mac OS X. Ppane is the backend tool\n    that does all the heavy lifting. It manages virtual hosts in your Apache configuration\n    as well as hostname registration with Domain Services.\n"
+email: 
+- eloy@fngtps.com
+- manfred@fngtps.com
+executables: 
+- ppane
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+files: 
+- lib/option_parser.rb
+- lib/passenger_pane/application.rb
+- lib/passenger_pane/configuration.rb
+- lib/passenger_pane/directory_services.rb
+- lib/passenger_pane/httpd_conf.rb
+- lib/passenger_pane/runner.rb
+- lib/passenger_pane.rb
+- LICENSE
+- bin/ppane
+has_rdoc: true
+homepage: 
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=utf-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: "Configuration tool for applications running on Phusion Passenger\xE2\x84\xA2."
+test_files: []
+