local_pac 0.0.7 → 0.1.0

data/Gemfile

@@ -10,6 +10,8 @@ group :test do
   gem 'simplecov', require: false
   gem 'rubocop', require: false
   gem 'coveralls', require: false
+  gem 'cucumber', require: false
+  gem 'aruba', require: false
 end
 
 group :development do

data/bin/local_pac

@@ -1,19 +1,64 @@
 #!/usr/bin/env ruby
 # encoding: utf-8
 require 'thor'
+require 'fileutils'
 
 $LOAD_PATH << File.expand_path('../../lib', __FILE__)
 require 'local_pac'
 
 class Default < Thor
+  class_option :config_file, type: :string, desc: 'Config file'
+  class_option :log_level, type: :string, desc: 'Log level for ui logging'
+
   desc 'serve', 'Serve pacfiles'
-  option :logfile, type: :string, default: File.expand_path(File.join(ENV['HOME'], '.local', 'share', 'local_pac', 'access.log')), desc: 'File to write access log to'
+  option :access_log, type: :string, desc: 'File to write access log to'
   option :port, type: :numeric, default: 8000, desc: 'The port the server listens on'
   def serve
-    LocalPac::FileServer.use Rack::CommonLogger, LocalPac::Logger.new(options[:logfile])
+    LocalPac.config(LocalPac::Config.new(options[:config_file])) if options[:config_file]
+    access_log = options[:access_log] || ::File.join(LocalPac.config.log_sink, 'access.log')
+
+    case options[:log_level]
+    when 'info'
+      LocalPac.ui_logger.level = Logger::INFO
+    when 'debug'
+      LocalPac.ui_logger.level = Logger::DEBUG
+    else
+      LocalPac.ui_logger.level = Logger::WARN
+    end
+
+    LocalPac.ui_logger.debug('Options: ' + options.to_s)
+    LocalPac.ui_logger.debug("Config:\n" + LocalPac.config.to_s)
+
+    LocalPac::FileServer.use Rack::CommonLogger, LocalPac::Logger.new(access_log)
     LocalPac::FileServer.set :port, options[:port]
     LocalPac::FileServer.run!
   end
+
+  desc 'init', 'Create files/directories to use local_pac in dir or $PWD'
+  option :force, type: :boolean, default: false, desc: 'Overwrite existing files?'
+  def init
+    LocalPac.config(LocalPac::Config.new(options[:config_file])) if options[:config_file]
+
+    case options[:log_level]
+    when 'info'
+      LocalPac.ui_logger.level = Logger::INFO
+    when 'debug'
+      LocalPac.ui_logger.level = Logger::DEBUG
+    else
+      LocalPac.ui_logger.level = Logger::WARN
+    end
+
+    LocalPac.ui_logger.debug('Options: ' + options.to_s)
+    LocalPac.ui_logger.debug("Config:\n" + LocalPac.config.to_s)
+
+    LocalPac::Initializer.new(force: options[:force]).run
+  end
+
+  desc 'config', 'Show configuration'
+  def config
+    LocalPac.config(LocalPac::Config.new(options[:config_file])) if options[:config_file]
+    puts LocalPac.config
+  end
 end
 
 Default.start

data/features/initializer.feature

@@ -0,0 +1,23 @@
+Feature: Initialize environment
+  As a administrator
+  I want to have utility to init environment for local_pac
+  In order to make less mistakes
+
+  @wip
+  Scenario: Not initialized
+    Given a file named "config.yaml" with:
+    """
+    pid_file: 'run/pid'
+    local_storage: 'storage'
+    log_sink: 'log'
+    executable: 'bin/local_pac'
+    """
+    When I successfully run `local_pac init --config-file config.yaml`
+    Then the following directories should exist:
+      | directory |
+      | 'run' |
+      | 'storage/cache.git' |
+      | 'log' |
+    And the following files should exist:
+      | file |
+      | 'storage/cache.git/hooks/pre-receive' |

data/features/show_config.feature

@@ -0,0 +1,22 @@
+Feature: Show config
+  As a administrator
+  I want to have utility to show config of local pac
+  In order to make less mistakes
+
+  @wip
+  Scenario: Default
+    Given a file named "config.yaml" with:
+    """
+    pid_file: 'run/pid'
+    local_storage: 'storage'
+    log_sink: 'log'
+    executable: 'bin/local_pac'
+    """
+    When I successfully run `local_pac config`
+    Then the stdout should contain:
+    """
+    pid_file: 'run/pid'
+    local_storage: 'storage'
+    log_sink: 'log'
+    executable: 'bin/local_pac'
+    """

data/features/support/env.rb

@@ -1 +1 @@
-require 'local_pac'
+require 'aruba/cucumber'

data/files/config.yaml

@@ -0,0 +1,6 @@
+---
+:storage_path: ~/.local/share/pacfiles/cache/cache.pstore
+:import_paths:
+- ~/.local/share/pacfiles/new
+- ~/.pacfiles/new
+- /var/pacfiles/new

data/files/git-hook.erb

@@ -0,0 +1,24 @@
+#!/usr/bin/env ruby
+
+<% Array(lookup('gem_path')).each do |p| -%>
+$LOAD_PATH.unshift '<%= p %>'
+<% end -%>
+
+require 'git_hook-pre_receive'
+require 'pac'
+
+class PacFileSyntaxChecker
+  def check(files)
+    files.each do |f|
+      begin
+        PAC.load f.content
+      rescue
+        $stderr.puts "Syntax error found in #{f.name}. Please check files locally again, fix the error and send update via git."
+        exit 1
+      end
+    end
+  end
+end
+
+parser = Git::PreReceiveHookParser.new($stdin.read)
+PacFileSyntaxChecker.new.check(parser.files)

data/lib/local_pac/actions/create_directory.rb

@@ -0,0 +1,33 @@
+# encoding: utf-8
+module LocalPac
+  module Actions
+    class CreateDirectory
+      private
+
+      attr_reader :fs_engine, :path, :options
+
+      public
+
+      def initialize(path, options = {}, fs_engine = FileUtils)
+        @path        = path
+        @options     = options
+        @fs_engine  = fs_engine
+      end
+
+      def run
+        if need_to_run? || options[:force] == true
+          LocalPac.ui_logger.warn "Creating repository \"#{path}\"."
+          fs_engine.mkdir_p(path)
+        else
+          LocalPac.ui_logger.warn "Repository \"#{path}\" already exists. Do not create it again!."
+        end
+      end
+
+      private
+
+      def need_to_run?
+        !File.exists?(path)
+      end
+    end
+  end
+end

data/lib/local_pac/actions/create_file.rb

@@ -0,0 +1,48 @@
+# encoding: utf-8
+module LocalPac
+  module Actions
+    class CreateFile
+      private
+
+      attr_reader :name, :destination, :data, :options, :engine, :repository
+
+      public
+
+      def initialize(name, destination, data, options = {}, engine = ErbGenerator, repository = TemplateRepository.new)
+        @name        = name
+        @destination = destination
+        @data        = data
+        @options     = options
+        @engine      = engine
+        @repository  = repository
+      end
+
+      def run
+        if need_to_run? || options[:force] == true
+          LocalPac.ui_logger.warn "Creating file \"#{destination}\"."
+
+          FileUtils.chmod('+x', template(name, destination, data)) if options[:executable] == true
+        else
+          LocalPac.ui_logger.warn "File \"#{destination}\" already exists. Do not create it again!."
+        end
+      end
+
+      private
+
+      def template(local_name, local_destination, local_data)
+        template = repository.find(local_name)
+
+        generator = engine.new(local_data)
+        generator.compile(template, ::File.new(local_destination, 'w'))
+
+        local_destination
+      rescue Errno::ENOENT
+        fail Exceptions::ErbTemplateIsUnknown, "Unknown erb template \"#{template_path}\"."
+      end
+
+      def need_to_run?
+        !File.exists?(destination)
+      end
+    end
+  end
+end

data/lib/local_pac/actions/create_repository.rb

@@ -0,0 +1,38 @@
+# encoding: utf-8
+module LocalPac
+  module Actions
+    class CreateRepository
+      private
+
+      attr_reader :vcs_engine, :path, :options
+
+      public
+
+      def initialize(path, options = {}, vcs_engine = LocalPac::Git)
+        @path        = path
+        @options     = options
+        @vcs_engine  = vcs_engine
+      end
+
+      def run
+        if need_to_run? || options[:force] == true
+          LocalPac.ui_logger.warn "Creating repository \"#{path}\"."
+
+          if options[:bare] == true
+            vcs_engine.init(path, true)
+          else
+            vcs_engine.init(path)
+          end
+        else
+          LocalPac.ui_logger.warn "Repository \"#{path}\" already exists. Do not create it again!."
+        end
+      end
+
+      private
+
+      def need_to_run?
+        !File.exists?(path)
+      end
+    end
+  end
+end

data/lib/local_pac/config.rb

@@ -0,0 +1,64 @@
+# encoding: utf-8
+module LocalPac
+  class Config
+    private
+
+    attr_reader :config
+
+    @options = []
+    class << self
+
+      attr_reader :options
+
+      def option(option, default_value)
+        define_method option.to_sym do
+          config.transaction do
+            config.fetch(option.to_sym, default_value)
+          end
+        end
+
+        @options << option
+      end
+    end
+
+    public
+
+    def initialize(file = available_config_file, config_engine = YAML::Store)
+      @config = config_engine.new(file)
+    end
+
+    option :log_sink, File.join(ENV['HOME'], '.local', 'share', 'local_pac', 'log')
+    option :local_storage, File.join(ENV['HOME'], '.local', 'share', 'local_pac', 'data')
+    option :executable, File.expand_path('../../../bin/local_pac', __FILE__)
+    option :pid_file, File.join(ENV['HOME'], '.local', 'share', 'local_pac', 'run', 'pid')
+    option :gem_path, Gem.path
+
+    def to_s
+      result = []
+      result << sprintf("%20s | %s", 'option', 'value')
+      result << sprintf("%s + %s", '-' * 20, '-' * 80)
+
+      Config.options.each do |o|
+        result << sprintf("%20s | %s", o, Array(public_send(o)).join(', '))
+      end
+
+      result.join("\n")
+    end
+
+    private
+
+    def candiate_files
+      [
+        File.expand_path(File.join(Dir.getwd, 'config.yaml')),
+        File.expand_path(File.join(ENV['HOME'], '.config', 'local_pac', 'config.yaml')),
+        File.expand_path(File.join(ENV['HOME'], '.local_pac', 'config.yaml')),
+        File.expand_path(File.join('/etc', 'local_pac', 'config.yaml')),
+        File.expand_path('../../../files/config.yaml', __FILE__),
+      ]
+    end
+
+    def available_config_file
+      candiate_files.find { |f| File.exists? f }
+    end
+  end
+end

data/lib/local_pac/data.rb

@@ -0,0 +1,23 @@
+module LocalPac
+  class Data
+    private
+
+    attr_reader :config
+
+    public
+
+    def initialize(config = LocalPac.config)
+      @config = config
+    end
+
+    def instance_binding
+      binding
+    end
+
+    def lookup(variable)
+      config.public_send variable.to_sym
+    rescue NoMethodError
+      fail "Variable \"#{variable}\" not found."
+    end
+  end
+end

data/lib/local_pac/erb_generator.rb

@@ -0,0 +1,34 @@
+# encoding: utf-8
+module LocalPac
+  # Used to generate the template
+  class ErbGenerator
+    private
+
+    attr_reader :data
+
+    public
+
+    # Create erb generator
+    #
+    # @param [Data] data
+    # The data class to be used within the template
+    def initialize(data)
+      @data = data
+    end
+
+    # Compile the template
+    #
+    # @param [IO] source
+    # The source template to be used
+    # @param [IO] destination
+    # The output io handle
+    def compile(source, destination)
+      erb = ERB.new(source.read, nil, '-')
+      begin
+        destination.puts erb.result(data.instance_binding)
+      rescue SyntaxError => e
+        raise Exceptions::ErbTemplateHasSyntaxErrors, e.message
+      end
+    end
+  end
+end

data/lib/local_pac/exceptions.rb

@@ -0,0 +1,9 @@
+module LocalPac
+  module Exceptions
+    # raise if there are template syntax errrors
+    class ErbTemplateHasSyntaxErrors < Exception; end
+
+    # raised if Template does not exist
+    class ErbTemplateIsUnknown < Exception; end
+  end
+end

data/lib/local_pac/file_server.rb

@@ -2,6 +2,15 @@ module LocalPac
   class FileServer < Sinatra::Base
     use Rack::Deflater
 
+    configure do
+      if settings.environment == :test
+        require_relative 'spec_helper_file_server'
+        SpecHelperFileServer.new
+      end
+
+      set :local_storage, LocalPac::LocalStorage.new
+    end
+
     configure do
       mime_type :proxy_pac_file, 'application/x-ns-proxy-autoconfig'
     end
@@ -16,9 +25,7 @@ module LocalPac
 
     get '/v1/pac/:name' do
       content_type :proxy_pac_file
-
-      manager = PacManager.new
-      file = manager.find(params[:name])
+      file = settings.local_storage.find(params[:name])
 
       if file.nil?
         fail Sinatra::NotFound, params[:name]

data/lib/local_pac/fileable.rb

@@ -0,0 +1,12 @@
+# encoding: utf-8
+module LocalPac
+  module Fileable
+    def mkdir_p(*args)
+      FileUtils.mkdir_p(*args)
+    end
+
+    def exist?(*args)
+      File.exist?(*args)
+    end
+  end
+end

data/lib/local_pac/git.rb

@@ -0,0 +1,63 @@
+module LocalPac
+  class Git
+    def self.ls_files(filter = nil)
+      cmd = ['git ls-files']
+      cmd << " #{filter}" if filter
+
+      runner = Runner.new(cmd.join(" "))
+      runner.result
+    end
+
+    def self.ls_tree(git_dir = nil)
+      cmd = ['git']
+      cmd << "--git-dir #{git_dir}" if git_dir
+      cmd << 'ls-tree -r HEAD'
+
+      runner = Runner.new(cmd.join(" "))
+      runner.result
+    end
+
+    def self.init(path, is_bare = false)
+      cmd = ["git init #{path}"]
+      cmd << "--bare" if is_bare
+
+      runner = Runner.new(cmd.join(" "))
+      runner.result
+    end
+
+    def self.add(object)
+      runner = Runner.new("git add #{object}")
+      runner.result
+    end
+
+    def self.commit(message)
+      runner = Runner.new("git commit -m \"#{message}\"")
+      runner.result
+    end
+
+    def self.status
+      runner = Runner.new('git status')
+      runner.result
+    end
+
+    def self.show(sha = nil, git_dir = nil)
+      cmd = ['git']
+      cmd << "--git-dir #{git_dir}" if git_dir
+      cmd << 'show'
+      cmd << " #{sha}" if sha
+
+      runner = Runner.new(cmd.join(" "))
+      runner.result
+    end
+
+    def self.cat_file(sha, git_dir = nil)
+      cmd = ['git']
+      cmd << "--git-dir #{git_dir}" if git_dir
+      cmd << 'cat-file -p'
+      cmd << sha
+
+      runner = Runner.new(cmd.join(" "))
+      runner.result
+    end
+  end
+end

data/lib/local_pac/git_file.rb

@@ -0,0 +1,18 @@
+# encoding: utf-8
+module LocalPac
+  class GitFile
+    attr_reader :path, :name, :content, :sha
+
+    def initialize(data, git_dir = nil)
+      data = data.split(" ")
+      @path    = data.last 
+      @sha     = data[2] 
+      @name    = path.sub(/.pac$/, '').camelize.downcase.to_sym
+      @content = Git.cat_file(@sha, git_dir).join("\n")
+    end
+
+    def to_s
+      "#{name}: #{path} (#{content})"
+    end
+  end
+end

data/lib/local_pac/git_repository.rb

@@ -0,0 +1,52 @@
+# encoding: utf-8
+module LocalPac
+
+  class GitRepository
+    private
+
+    attr_reader :storage_path, :data
+
+    public
+
+    def initialize(storage_path, compressor_engine = JavaScriptCompressor, file_creator = PacFile)
+      @storage_path = storage_path
+      javascript_compressor = compressor_engine.new
+
+      create unless ::File.exists? storage_path
+
+      mutex = Mutex.new
+      mutex.synchronize do
+        @data = pac_files.reduce({}) do |memo, git_file| 
+          pac_file = file_creator.new(git_file)
+          javascript_compressor.prepare(pac_file)
+          memo[pac_file.name.to_sym] = pac_file
+
+          memo
+        end
+      end
+    end
+
+    def [](name)
+      data[name]
+    end
+
+    private
+
+    def create
+      Git.init(storage_path)
+    end
+
+    def pac_files
+      Dir.chdir(storage_path) do
+        LocalPac.ui_logger.debug "I'm using the following storage path: \"#{storage_path}\"."
+
+        files = Git.ls_tree(storage_path).collect do |l|
+          GitFile.new(l)
+        end
+
+        LocalPac.ui_logger.debug "Found the following files: \"#{files.join(", ")}\"."
+        files
+      end
+    end
+  end
+end

data/lib/local_pac/initializer.rb

@@ -0,0 +1,28 @@
+module LocalPac
+  class Initializer
+
+    private
+
+    attr_reader :config, :vcs, :options
+
+    include Fileable
+
+    public
+
+    def initialize(options = {}, config = LocalPac.config)
+      @config  = config
+      @options = options
+    end
+
+    def run
+      LocalPac.ui_logger.info "Creating pid directory: #{::File.dirname(config.pid_file)}"
+      Actions::CreateDirectory.new(::File.dirname(config.pid_file), force: options[:force]).run
+      LocalPac.ui_logger.info "Creating log sink: #{config.log_sink}"
+      Actions::CreateDirectory.new(config.log_sink, force: options[:force]).run
+      LocalPac.ui_logger.info "Creating local storage: #{config.local_storage}"
+      Actions::CreateRepository.new(config.local_storage, bare: true, force: options[:force]).run
+      LocalPac.ui_logger.info "Creating pre-receive hook in local storage \"#{config.local_storage}\"."
+      Actions::CreateFile.new(:'git-hook', File.join(config.local_storage, 'hooks', 'pre-receive'), Data.new(config), force: options[:force]).run
+    end
+  end
+end

data/lib/local_pac/local_storage.rb

@@ -0,0 +1,21 @@
+# encoding: utf-8
+module LocalPac
+  class LocalStorage
+    private
+
+    attr_reader :storage, :null_file
+
+    public
+
+    def initialize(storage = GitRepository.new(LocalPac.config.local_storage), null_file = NullPacFile.new )
+      @storage   = storage
+      @null_file = null_file
+    end
+
+    def find(name)
+      name = name.sub(/.pac$/, '').camelize.downcase.to_sym
+      LocalPac.ui_logger.debug "Using the following name to find pac file: \":#{name}\"."
+      storage[name] || null_file
+    end
+  end
+end

data/lib/local_pac/logger.rb

@@ -8,10 +8,5 @@ module LocalPac
     def write(*args, &block)
       @logger.<<(*args, &block)
     end
-
-    private
-
-    def default_path
-    end
   end
 end

data/lib/local_pac/main.rb

@@ -0,0 +1,24 @@
+# encoding: utf-8
+module LocalPac
+
+  @config_semaphore = Mutex.new
+  @logger_semaphore = Mutex.new
+
+  class << self
+    attr_reader :config_semaphore
+    attr_reader :logger_semaphore
+    attr_accessor :debug_mode
+
+    def config(local_config = LocalPac::Config.new)
+      config_semaphore.synchronize do
+        @config ||= local_config
+      end
+    end
+
+    def ui_logger(local_logger = LocalPac::UiLogger.new)
+      logger_semaphore.synchronize do
+        @ui_logger ||= local_logger
+      end
+    end
+  end
+end