devdnsd 3.1.2 → 4.0.0

data/lib/devdnsd/configuration.rb

@@ -65,28 +65,37 @@ module DevDNSd
       super(file, overrides, logger)
 
       # Make sure some arguments are of correct type
-      self.log_file = case log_file
-        when "STDOUT" then $stdout
-        when "STDERR" then $stderr
-        else File.absolute_path(File.expand_path(log_file))
-      end
+      self.log_file = resolve_log_file
 
       self.pid_file = File.absolute_path(File.expand_path(pid_file))
       self.port = port.to_integer
       self.log_level = log_level.to_integer
 
       # Add a default rule
-      add_rule(/.+/, "127.0.0.1") if rules.blank?
+      add_rule(match: /.+/, reply: "127.0.0.1") if rules.blank?
     end
 
     # Adds a rule to the configuration.
     #
-    # @param args [Array] The rule's arguments.
-    # @param block [Proc] An optional block for the rule.
+    # @param match [String|Regexp] The pattern to match.
+    # @param reply [String|Symbol] The IP or hostname to reply back to the client. It can be omitted (and it will be ignored) if a block is provided.
+    # @param type [Symbol] The type of request to match.
+    # @param options [Hash] A list of options for the request.
+    # @param block [Proc] An optional block to compute the reply instead of using the `reply` parameter.
     # @return [Array] The current set of rule.
-    # @see Rule.create
-    def add_rule(*args, &block)
-      rules << DevDNSd::Rule.create(*args, &block)
+    def add_rule(match: /.+/, reply: "127.0.0.1", type: :A, options: {}, &block)
+      rules << DevDNSd::Rule.create(match: match, reply: reply, type: type, options: options, &block)
+    end
+
+    private
+
+    # :nodoc:
+    def resolve_log_file
+      case log_file
+      when "STDOUT" then $stdout
+      when "STDERR" then $stderr
+      else File.absolute_path(File.expand_path(log_file))
+      end
     end
   end
 end

data/lib/devdnsd/errors.rb

@@ -11,4 +11,4 @@ module DevDNSd
     class InvalidRule < ::ArgumentError
     end
   end
-end
+end

data/lib/devdnsd/osx.rb

@@ -0,0 +1,217 @@
+# This file is part of the devdnsd gem. Copyright (C) 2013 and above Shogun <shogun@cowtech.it>.
+# Licensed under the MIT license, which can be found at http://www.opensource.org/licenses/mit-license.php.
+#
+
+# A small DNS server to enable local .dev domain resolution.
+module DevDNSd
+  # OSX management methods.
+  module OSX
+    # Gets the path for the resolver file.
+    #
+    # @param tld [String] The TLD to manage.
+    # @return [String] The path for the resolver file.
+    def resolver_path(tld = nil)
+      tld ||= @config.tld
+      "/etc/resolver/#{tld}"
+    end
+
+    # Gets the path for the launch agent file.
+    #
+    # @param name [String] The base name for the agent.
+    # @return [String] The path for the launch agent file.
+    def launch_agent_path(name = "it.cowtech.devdnsd")
+      ENV["HOME"] + "/Library/LaunchAgents/#{name}.plist"
+    end
+
+    # Executes a shell command.
+    #
+    # @param command [String] The command to execute.
+    # @return [Boolean] `true` if command succeeded, `false` otherwise.
+    def execute_command(command)
+      system("#{command} 2>&1 > /dev/null")
+    end
+
+    # Updates DNS cache.
+    #
+    # @return [Boolean] `true` if command succeeded, `false` otherwise.
+    def dns_update
+      @logger.info(i18n.dns_update)
+
+      script = Tempfile.new("devdnsd-dns-cache-script")
+      script.write("dscacheutil -flushcache 2>&1 > /dev/null\n")
+      script.write("killall -9 mDNSResponder 2>&1 > /dev/null\n")
+      script.write("killall -9 mDNSResponderHelper 2>&1 > /dev/null\n")
+      script.close
+
+      Kernel.system("/usr/bin/osascript -e 'do shell script \"sh #{script.path}\" with administrator privileges' 2>&1 > /dev/null")
+      script.unlink
+    end
+
+    # Checks if we are running on MacOS X.
+    #
+    # System services are only available on that platform.
+    #
+    # @return [Boolean] `true` if the current platform is MacOS X, `false` otherwise.
+    def osx?
+      ::RbConfig::CONFIG['host_os'] =~ /^darwin/
+    end
+    alias_method :is_osx?, :osx?
+
+    # Adds aliases to an interface.
+    #
+    # @param options [Hash] The options provided by the user.
+    # @return [Boolean] `true` if action succeeded, `false` otherwise.
+    def action_add(options)
+      manage_aliases(:add, i18n.add_empty, options)
+    end
+
+    # Removes aliases from an interface.
+    #
+    # @param options [Hash] The options provided by the user.
+    # @return [Boolean] `true` if action succeeded, `false` otherwise.
+    def action_remove(options)
+      manage_aliases(:remove, i18n.remove_empty, options)
+    end
+
+    # Installs the application into the autolaunch.
+    #
+    # @return [Boolean] `true` if action succeeded, `false` otherwise.
+    def action_install
+      manage_installation(launch_agent_path, resolver_path, :create_resolver, :create_agent, :load_agent)
+    end
+
+    # Uninstalls the application from the autolaunch.
+    #
+    # @return [Boolean] `true` if action succeeded, `false` otherwise.
+    def action_uninstall
+      manage_installation(launch_agent_path, resolver_path, :delete_resolver, :unload_agent, :delete_agent)
+    end
+
+    private
+
+    # :nodoc:
+    def log_status(pid, status)
+      logger.info(status == :running ? replace_markers(i18n.status_running(pid)) : replace_markers(i18n.send("status_#{status}")))
+    end
+
+    # :nodoc:
+    def manage_installation(launch_agent, resolver_path, first_operation, second_operation, third_operation)
+      rv = check_agent_available
+
+      logger.warn(replace_markers(i18n.admin_privileges_warning))
+      rv = send(first_operation, launch_agent, resolver_path) if rv
+      rv = send(second_operation, launch_agent, resolver_path) if rv
+      rv = send(third_operation, launch_agent, resolver_path) if rv
+      dns_update
+      rv
+    end
+
+    # :nodoc:
+    def delete_file(file, before_message, error_message)
+      logger.info(i18n.send(before_message, file))
+      ::File.delete(file)
+      true
+    rescue
+      logger.warn(i18n.send(error_message))
+      false
+    end
+
+    # :nodoc:
+    def check_agent_available
+      rv = true
+      unless osx?
+        logger.fatal(i18n.no_agent)
+        rv = false
+      end
+
+      rv
+    end
+
+    # :nodoc:
+    def create_resolver(_, resolver_path)
+      logger.info(replace_markers(i18n.resolver_creating(resolver_path)))
+
+      script_file = create_resolver_script(resolver_path)
+      Kernel.system("/usr/bin/osascript -e 'do shell script \"sh #{script_file.path}\" with administrator privileges' 2>&1 > /dev/null")
+      script_file.unlink
+      true
+    rescue
+      logger.error(i18n.resolver_creating_error)
+      false
+    end
+
+    # :nodoc:
+    def create_resolver_script(resolver_path)
+      script = "mkdir -p '#{File.dirname(resolver_path)}'\nrm -rf '#{resolver_path}'\necho 'nameserver 127.0.0.1\\nport #{@config.port}' >> '#{resolver_path}'"
+      f = Tempfile.new("devdnsd-install-script")
+      f.write(script)
+      f.close
+      f
+    end
+
+    # :nodoc:
+    def delete_resolver(_, resolver_path)
+      logger.info(i18n.resolver_deleting(resolver_path))
+      Kernel.system("/usr/bin/osascript -e 'do shell script \"rm #{resolver_path}\" with administrator privileges' 2>&1 > /dev/null")
+      true
+    rescue
+      logger.warn(i18n.resolver_deleting_error)
+      false
+    end
+
+    # :nodoc:
+    def create_agent(launch_agent, _)
+      logger.info(replace_markers(i18n.agent_creating(launch_agent)))
+      program, args = prepare_agent
+
+      ::File.open(launch_agent, "w") do |f|
+        f.write({"KeepAlive" => true, "Label" => "it.cowtech.devdnsd", "Program" => program, "ProgramArguments" => args, "RunAtLoad" => true}.to_plist)
+        f.flush
+      end
+
+      true
+    rescue
+      logger.error(i18n.agent_creating_error)
+      false
+    end
+
+    # :nodoc:
+    def prepare_agent
+      [
+        (::Pathname.new(Dir.pwd) + $PROGRAM_NAME).to_s,
+        (ARGV ? ARGV[0, ARGV.length - 1] : [])
+      ]
+    end
+
+    # :nodoc:
+    def delete_agent(launch_agent, _)
+      delete_file(launch_agent, :agent_deleting, :agent_deleting_error)
+    end
+
+    # :nodoc:
+    def load_agent(launch_agent, _)
+      toggle_agent(launch_agent, "load", :agent_loading, :agent_loading_error, :error)
+    end
+
+    # :nodoc:
+    def unload_agent(launch_agent, _)
+      toggle_agent(launch_agent, "unload", :agent_unloading, :agent_unloading_error, :warn)
+    end
+
+    # :nodoc:
+    def toggle_agent(launch_agent, operation, info_message, error_message, error_level)
+      logger.info(i18n.send(info_message, launch_agent))
+      raise RuntimeError unless File.exist?(launch_agent)
+      execute_command("launchctl #{operation} -w \"#{launch_agent}\" > /dev/null 2>&1")
+      true
+    rescue
+      logger.send(error_level, i18n.send(error_message))
+      false
+    end
+
+    # :nodoc:
+    def replace_markers(message)
+      @command.application.console.replace_markers(message)
+    end
+  end
+end

data/lib/devdnsd/rule.rb

@@ -24,19 +24,54 @@ module DevDNSd
     attr_accessor :options
     attr_accessor :block
 
-    include Lazier::I18n
+    # Class methods
+    class << self
+      # Creates a new rule.
+      #
+      # @param match [String|Regexp] The pattern to match.
+      # @param reply [String|Symbol] The IP or hostname to reply back to the client. It can be omitted (and it will be ignored) if a block is provided.
+      # @param type [Symbol] The type of request to match.
+      # @param options [Hash] A list of options for the request.
+      # @param block [Proc] An optional block to compute the reply instead of using the `reply` parameter.
+      # @return [Rule] The new rule.
+      def create(match: /.+/, reply: "127.0.0.1", type: :A, options: {}, &block)
+        new(match: match, reply: reply, type: type, options: options, &block)
+      end
+
+      # Converts a class to the correspondent symbol.
+      #
+      # @param klass [Class] The class to convert.
+      # @return [Symbol] The symbol representation of the class.
+      def resource_class_to_symbol(klass)
+        klass.to_s.gsub(/(.+::)?(.+)/, "\\2").to_sym
+      end
+
+      # Converts a symbol to the correspondent DNS resource class.
+      #
+      # @param symbol [Symbol] The symbol to convert.
+      # @param locale [Symbol] The locale to use for the messages.
+      # @return [Symbol] The class associated to the symbol.
+      def symbol_to_resource_class(symbol, locale = nil)
+        symbol = symbol.to_s.upcase
+
+        begin
+          "Resolv::DNS::Resource::IN::#{symbol}".constantize
+        rescue ::NameError
+          i18n = Bovem::I18n.new(locale, root: "devdnsd", path: ::Pathname.new(::File.dirname(__FILE__)).to_s + "/../../locales/")
+          raise(DevDNSd::Errors::InvalidRule, i18n.rule_invalid_resource(symbol))
+        end
+      end
+    end
 
     # Creates a new rule.
     #
     # @param match [String|Regexp] The pattern to match.
-    # @param reply [String] The IP or hostname to reply back to the client.
+    # @param reply [String|Symbol] The IP or hostname to reply back to the client. It can be omitted (and it will be ignored) if a block is provided.
     # @param type [Symbol] The type of request to match.
     # @param options [Hash] A list of options for the request.
     # @param block [Proc] An optional block to compute the reply instead of using the `reply` parameter.
     # @see .create
-    def initialize(match = /.+/, reply = "127.0.0.1", type = :A, options = {}, &block)
-      i18n_setup(:devdnsd, ::File.absolute_path(::Pathname.new(::File.dirname(__FILE__)).to_s + "/../../locales/"))
-      self.i18n = options[:locale]
+    def initialize(match: /.+/, reply: "127.0.0.1", type: :A, options: {}, &block)
       setup(match, reply, type, options, block)
       validate_rule
     end
@@ -45,122 +80,58 @@ module DevDNSd
     #
     # @return [Array|Class] The class(es) for the current rule.
     def resource_class
-      classes = @type.ensure_array(nil, true, true, true) {|cls| self.class.symbol_to_resource_class(cls, options[:locale]) }
+      classes = @type.ensure_array(no_duplicates: true, compact: true, flatten: true) { |cls| self.class.symbol_to_resource_class(cls, options[:locale]) }
       classes.length == 1 ? classes.first : classes
     end
 
     # Checks if the rule is a regexp.
     #
     # @return [Boolean] `true` if the rule is a Regexp, `false` otherwise.
-    def is_regexp?
+    def regexp?
       @match.is_a?(::Regexp)
     end
+    alias_method :is_regexp?, :regexp?
 
     # Checks if the rule is a regexp.
     #
     # @return [Boolean] `true` if the rule has a block, `false` otherwise.
-    def has_block?
+    def block?
       @block.present?
     end
+    alias_method :has_block?, :block?
 
     # Matches a hostname to the rule.
     #
     # @param hostname [String] The hostname to match.
     # @return [MatchData|Boolean|Nil] Return `true` or MatchData (if the pattern is a regexp) if the rule matches, `false` or `nil` otherwise.
     def match_host(hostname)
-      is_regexp? ? @match.match(hostname) : (@match == hostname)
-    end
-
-    # Creates a new rule.
-    #
-    # @param match [String|Regexp] The pattern to match.
-    # @param reply_or_type [String|Symbol] The IP or hostname to reply back to the client (or the type of request to match, if a block is provided).
-    # @param type [Symbol] The type of request to match. This is ignored if a block is provided.
-    # @param options [Hash] A list of options for the request.
-    # @param block [Proc] An optional block to compute the reply instead of using the `reply_or_type` parameter. In this case `reply_or_type` is used for the type of the request and `type` is ignored.
-    # @return [Rule] The new rule.
-    def self.create(match, reply_or_type = nil, type = nil, options = {}, &block)
-      validate_options(reply_or_type, options, block, Lazier::Localizer.new(:devdnsd, ::File.absolute_path(::Pathname.new(::File.dirname(__FILE__)).to_s + "/../../locales/"), options.is_a?(Hash) ? options[:locale] : nil))
-      setup(new(match), reply_or_type, type, options, block)
-    end
-
-    # Converts a class to the correspondent symbol.
-    #
-    # @param klass [Class] The class to convert.
-    # @return [Symbol] The symbol representation of the class.
-    def self.resource_class_to_symbol(klass)
-      klass.to_s.gsub(/(.+::)?(.+)/, "\\2").to_sym
+      regexp? ? @match.match(hostname) : (@match == hostname)
     end
 
-    # Converts a symbol to the correspondent DNS resource class.
-    #
-    # @param symbol [Symbol] The symbol to convert.
-    # @param locale [Symbol] The locale to use for the messages.
-    # @return [Symbol] The class associated to the symbol.
-    def self.symbol_to_resource_class(symbol, locale = nil)
-      symbol = symbol.to_s.upcase
+    private
 
-      begin
-        "Resolv::DNS::Resource::IN::#{symbol}".constantize
-      rescue ::NameError
-        raise(DevDNSd::Errors::InvalidRule.new(Lazier::Localizer.new(:devdnsd, ::File.absolute_path(::Pathname.new(::File.dirname(__FILE__)).to_s + "/../../locales/"), locale).i18n.invalid_class(symbol)))
-      end
-    end
+    # :nodoc:
+    def setup(match, reply, type, options, block)
+      @match = match
 
-    private
-      # Setups a new rule.
-      #
-      # @param match [String|Regexp] The pattern to match.
-      # @param reply [String] The IP or hostname to reply back to the client.
-      # @param type [Symbol] The type of request to match.
-      # @param options [Hash] A list of options for the request.
-      # @param block [Proc] An optional block to compute the reply instead of using the `reply` parameter.
-      def setup(match, reply, type, options, block)
-        @match = match
+      if block.present? # reply acts like a type, type is ignored
+        @type = type || :A
+        @reply = nil
+      else # reply acts like a reply
+        @reply = reply || "127.0.0.1"
         @type = type || :A
-        @reply = block.blank? ? (reply || "127.0.0.1") : nil
-        @options = options
-        @block = block
-      end
-
-      # Validates a newly created rule.
-      def validate_rule
-        raise(DevDNSd::Errors::InvalidRule.new(i18n.rule_invalid_call)) if @reply.blank? && @block.nil?
-        raise(DevDNSd::Errors::InvalidRule.new(i18n.rule_invalid_options)) if !@options.is_a?(::Hash)
       end
 
-      # Setups a new rule.
-      #
-      # @param rv [Rule] The rule that is been created.
-      # @param reply_or_type [String|Symbol] The IP or hostname to reply back to the client (or the type of request to match, if a block is provided).
-      # @param type [Symbol] The type of request to match. This is ignored if a block is provided.
-      # @param options [Hash] A list of options for the request.
-      # @param block [Proc] An optional block to compute the reply instead of using the `reply_or_type` parameter. In this case `reply_or_type` is used for the type of the request and `type` is ignored.
-      # @return [Rule] The new rule.
-      def self.setup(rv, reply_or_type, type, options = {}, block)
-        rv.options = options
-        rv.block = block
-
-        if block.present? then # reply_or_type acts like a type, type is ignored
-          rv.type = reply_or_type || :A
-          rv.reply = nil
-        else # reply_or_type acts like a reply
-          rv.reply = reply_or_type || "127.0.0.1"
-          rv.type = type || :A
-        end
-
-        rv
-      end
+      @options = options
+      @block = block
+      locale = options.is_a?(Hash) ? options[:locale] : :en
+      @i18n = Bovem::I18n.new(locale, root: "devdnsd", path: ::Pathname.new(::File.dirname(__FILE__)).to_s + "/../../locales/")
+    end
 
-      # Validate options for a new rule creation.
-      #
-      # @param reply_or_type [String|Symbol] The IP or hostname to reply back to the client (or the type of request to match, if a block is provided).
-      # @param options [Hash] A list of options for the request.
-      # @param block [Proc] An optional block to compute the reply instead of using the `reply_or_type` parameter. In this case `reply_or_type` is used for the type of the request and `type` is ignored.
-      # @param localizer [Localizer] A localizer object.
-      def self.validate_options(reply_or_type, options, block, localizer)
-        raise(DevDNSd::Errors::InvalidRule.new(localizer.i18n.rule_invalid_call)) if reply_or_type.blank? && block.nil?
-        raise(DevDNSd::Errors::InvalidRule.new(localizer.i18n.rule_invalid_options)) if !options.is_a?(::Hash)
-      end
+    # Validates a newly created rule.
+    def validate_rule
+      raise(DevDNSd::Errors::InvalidRule, @i18n.rule_invalid_call) if @reply.blank? && @block.nil?
+      raise(DevDNSd::Errors::InvalidRule, @i18n.rule_invalid_options) unless @options.is_a?(::Hash)
+    end
   end
 end