txgh 1.0.0

data/lib/txgh/handlers/github/push_handler.rb

@@ -0,0 +1,108 @@
+require 'base64'
+
+module Txgh
+  module Handlers
+    module Github
+      class PushHandler < Handler
+
+        def execute
+          # Check if the branch in the hook data is the configured branch we want
+          logger.info("request github branch: #{branch}")
+          logger.info("config github branch: #{repo.github_config_branch}")
+
+          if repo.should_process_ref?(branch)
+            logger.info('found branch in github request')
+
+            tx_resources = tx_resources_for(branch)
+            modified_resources = added_and_modified_resources_for(tx_resources)
+            modified_resources.merge!(l10n_resources_for(tx_resources))
+
+            if repo.github_config_branch.include?('tags/')
+              modified_resources.merge!(tag_resources_for(tx_resources))
+            end
+
+            # Handle DBZ 'L10N' special case
+            if branch.include?("L10N")
+              logger.info('processing L10N tag')
+
+              # Create a new branch off tag commit
+              if branch.include?('tags/L10N')
+                repo.api.create_ref(repo.name, 'heads/L10N', payload['head_commit']['id'])
+              end
+            end
+
+            updater = ResourceUpdater.new(project, repo, logger)
+            categories = { 'author' => payload['head_commit']['committer']['name'] }
+
+            modified_resources.each_pair do |resource, commit_sha|
+              updater.update_resource(resource, commit_sha, categories)
+            end
+          end
+
+          respond_with(200, true)
+        end
+
+        private
+
+        def tag_resources_for(tx_resources)
+          payload['head_commit']['modified'].each_with_object({}) do |modified, ret|
+            logger.info("processing modified file: #{modified}")
+
+            if tx_resources.include?(modified)
+              ret[tx_resources[modified]] = payload['head_commit']['id']
+            end
+          end
+        end
+
+        def l10n_resources_for(tx_resources)
+          payload['head_commit']['modified'].each_with_object({}) do |modified, ret|
+            if tx_resources.include?(modified)
+              logger.info("setting new resource: #{tx_resources[modified].L10N_resource_slug}")
+              ret[tx_resources[modified]] = payload['head_commit']['id']
+            end
+          end
+        end
+
+        # Finds the updated resources and maps the most recent commit in which
+        # each was modified
+        def added_and_modified_resources_for(tx_resources)
+          payload['commits'].each_with_object({}) do |commit, ret|
+            logger.info('processing commit')
+
+            (commit['modified'] + commit['added']).each do |file|
+              logger.info("processing added/modified file: #{file}")
+
+              if tx_resources.include?(file)
+                ret[tx_resources[file]] = commit['id']
+              end
+            end
+          end
+        end
+
+        # Build an index of known Tx resources, by source file
+        def tx_resources_for(branch)
+          tx_config.resources.each_with_object({}) do |resource, ret|
+            logger.info('processing resource')
+
+            # If we're processing by branch, create a branch resource. Otherwise,
+            # use the original resource.
+            ret[resource.source_file] = if repo.process_all_branches?
+              TxBranchResource.new(resource, branch)  # maybe find instead?
+            else
+              resource
+            end
+          end
+        end
+
+        def tx_config
+          @tx_config ||= Txgh::Config::TxManager.tx_config(project, repo, branch)
+        end
+
+        def branch
+          @ref ||= payload['ref'].sub(/^refs\//, '')
+        end
+
+      end
+    end
+  end
+end

data/lib/txgh/handlers/github/request_handler.rb

@@ -0,0 +1,106 @@
+require 'json'
+
+module Txgh
+  module Handlers
+    module Github
+      class RequestHandler
+        class << self
+
+          include ResponseHelpers
+
+          def handle_request(request, logger)
+            case request.env['HTTP_X_GITHUB_EVENT']
+              when 'push'
+                handle_push(request, logger)
+              when 'delete'
+                handle_delete(request, logger)
+              else
+                handle_unexpected
+            end
+          end
+
+          private
+
+          def handle_push(request, logger)
+            klass = Txgh::Handlers::Github::PushHandler
+            new(request, logger).handle(klass)
+          end
+
+          def handle_delete(request, logger)
+            klass = Txgh::Handlers::Github::DeleteHandler
+            new(request, logger).handle(klass)
+          end
+
+          def handle_unexpected
+            respond_with_error(400, 'Unexpected event type')
+          end
+
+        end
+
+        include ResponseHelpers
+
+        attr_reader :request, :logger
+
+        def initialize(request, logger)
+          @request = request
+          @logger = logger
+        end
+
+        def handle(klass)
+          handle_safely do
+            handler = klass.new(
+              project: config.transifex_project,
+              repo: config.github_repo,
+              payload: payload,
+              logger: logger
+            )
+
+            handler.execute
+          end
+        end
+
+        private
+
+        def handle_safely
+          if authentic_request?
+            yield
+          else
+            respond_with_error(401, 'Unauthorized')
+          end
+        rescue => e
+          respond_with_error(500, "Internal server error: #{e.message}", e)
+        end
+
+        def payload
+          @payload ||= if request.params[:payload]
+            JSON.parse(request.params[:payload])
+          else
+            JSON.parse(request.body.read)
+          end
+        end
+
+        def github_repo_name
+          payload['repository']['full_name']
+        end
+
+        def config
+          @config ||= Txgh::Config::KeyManager.config_from_repo(github_repo_name)
+        end
+
+        def repo
+          config.github_repo
+        end
+
+        def authentic_request?
+          if repo.webhook_protected?
+            GithubRequestAuth.authentic_request?(
+              request, repo.webhook_secret
+            )
+          else
+            true
+          end
+        end
+      end
+    end
+  end
+end

data/lib/txgh/handlers/response.rb

@@ -0,0 +1,17 @@
+module Txgh
+  module Handlers
+    class Response
+      attr_reader :status, :body, :error
+
+      def initialize(status, body, error = nil)
+        @status = status
+        @body = body
+        @error = error
+      end
+
+      def streaming?
+        false
+      end
+    end
+  end
+end

data/lib/txgh/handlers/stream_response.rb

@@ -0,0 +1,39 @@
+require 'mime/types'
+
+module Txgh
+  module Handlers
+    class StreamResponse
+      attr_reader :attachment, :enum
+
+      def initialize(attachment, enum)
+        @attachment = attachment
+        @enum = enum
+      end
+
+      def write_to(stream)
+        raise NotImplementedError,
+          "please implement #{__method__} in derived classes"
+      end
+
+      def file_extension
+        raise NotImplementedError,
+          "please implement #{__method__} in derived classes"
+      end
+
+      def headers
+        @headers ||= {
+          'Content-Disposition' => "attachment; filename=\"#{attachment}#{file_extension}\"",
+          'Content-Type' => MIME::Types.type_for(file_extension).first.content_type
+        }
+      end
+
+      def streaming?
+        true
+      end
+
+      def error
+        nil
+      end
+    end
+  end
+end

data/lib/txgh/handlers/tgz_stream_response.rb

@@ -0,0 +1,41 @@
+require 'rubygems/package'
+require 'stringio'
+require 'zlib'
+
+module Txgh
+  module Handlers
+    class TgzStreamResponse < StreamResponse
+      PERMISSIONS = 0644
+
+      def write_to(stream)
+        Zlib::GzipWriter.wrap(stream) do |gz|
+          pipe = StringIO.new('', 'wb')
+          tar = Gem::Package::TarWriter.new(pipe)
+
+          enum.each do |file_name, contents|
+            tar.add_file(file_name, PERMISSIONS) do |f|
+              f.write(contents)
+            end
+
+            flush(tar, pipe, gz)
+            stream.flush
+          end
+
+          flush(tar, pipe, gz)
+        end
+      end
+
+      def file_extension
+        '.tgz'
+      end
+
+      private
+
+      def flush(tar, pipe, gz)
+        tar.flush
+        gz.write(pipe.string)
+        pipe.reopen('')
+      end
+    end
+  end
+end

data/lib/txgh/handlers/transifex.rb

@@ -0,0 +1,8 @@
+module Txgh
+  module Handlers
+    module Transifex
+      autoload :HookHandler,    'txgh/handlers/transifex/hook_handler'
+      autoload :RequestHandler, 'txgh/handlers/transifex/request_handler'
+    end
+  end
+end

data/lib/txgh/handlers/transifex/hook_handler.rb

@@ -0,0 +1,77 @@
+require 'logger'
+
+module Txgh
+  module Handlers
+    module Transifex
+      class HookHandler
+        include CategorySupport
+        include ResponseHelpers
+
+        attr_reader :project, :repo, :resource_slug, :language, :logger
+
+        def initialize(options = {})
+          @project = options.fetch(:project)
+          @repo = options.fetch(:repo)
+          @resource_slug = options.fetch(:resource_slug)
+          @language = options.fetch(:language)
+          @logger = options.fetch(:logger) { Logger.new(STDOUT) }
+        end
+
+        def execute
+          logger.info(resource_slug)
+
+          if tx_config
+            if tx_resource
+              committer = ResourceCommitter.new(project, repo, logger)
+              committer.commit_resource(tx_resource, branch, language)
+
+              respond_with(200, true)
+            else
+              respond_with_error(
+                404, "Could not find resource '#{resource_slug}' in config"
+              )
+            end
+          else
+            respond_with_error(
+              404, "Could not find configuration for branch '#{branch}'"
+            )
+          end
+        end
+
+        private
+
+        def tx_config
+          @tx_config ||= Txgh::Config::TxManager.tx_config(project, repo, branch)
+        rescue ConfigNotFoundError, TxghError
+          nil
+        end
+
+        def branch
+          @branch ||= begin
+            branch_candidate = if process_all_branches?
+              resource = project.api.get_resource(project.name, resource_slug)
+              categories = deserialize_categories(Array(resource['categories']))
+              categories['branch']
+            else
+              repo.branch || 'master'
+            end
+
+            Utils.absolute_branch(branch_candidate)
+          end
+        end
+
+        def tx_resource
+          @tx_resource ||= if process_all_branches?
+            tx_config.resource(resource_slug, branch)
+          else
+            tx_config.resource(resource_slug)
+          end
+        end
+
+        def process_all_branches?
+          repo.process_all_branches?
+        end
+      end
+    end
+  end
+end

data/lib/txgh/handlers/transifex/request_handler.rb

@@ -0,0 +1,78 @@
+require 'uri'
+
+module Txgh
+  module Handlers
+    module Transifex
+      class RequestHandler
+        class << self
+
+          def handle_request(request, logger)
+            new(request, logger).handle(Txgh::Handlers::Transifex::HookHandler)
+          end
+
+        end
+
+        include ResponseHelpers
+
+        attr_reader :request, :logger
+
+        def initialize(request, logger)
+          @request = request
+          @logger = logger
+        end
+
+        def handle(klass)
+          handle_safely do
+            handler = klass.new(
+              project: config.transifex_project,
+              repo: config.github_repo,
+              resource_slug: payload['resource'],
+              language: payload['language'],
+              logger: logger
+            )
+
+            handler.execute
+          end
+        end
+
+        private
+
+        def handle_safely
+          if authentic_request?
+            yield
+          else
+            respond_with_error(401, 'Unauthorized')
+          end
+        rescue => e
+          respond_with_error(500, "Internal server error: #{e.message}", e)
+        end
+
+        def authentic_request?
+          if project.webhook_protected?
+            TransifexRequestAuth.authentic_request?(
+              request, project.webhook_secret
+            )
+          else
+            true
+          end
+        end
+
+        def project
+          config.transifex_project
+        end
+
+        def config
+          @config ||= Txgh::Config::KeyManager.config_from_project(payload['project'])
+        end
+
+        def payload
+          @payload ||= begin
+            request.body.rewind
+            Hash[URI.decode_www_form(request.body.read)]
+          end
+        end
+
+      end
+    end
+  end
+end