txgh-server 1.0.0.beta1

data/lib/txgh-server/webhooks/github/push_handler.rb

@@ -0,0 +1,124 @@
+require 'base64'
+require 'set'
+
+module TxghServer
+  module Webhooks
+    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 should_process?
+            logger.info('found branch in github request')
+
+            tx_resources = tx_resources_for(branch)
+
+            modified_resources = added_and_modified_resources_for(tx_resources)
+            modified_resources += l10n_resources_for(tx_resources)
+
+            if repo.github_config_branch.include?('tags/')
+              modified_resources += 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 = Txgh::ResourceUpdater.new(project, repo, logger)
+            categories = { 'author' => payload['head_commit']['committer']['name'] }
+            ref = repo.api.get_ref(repo.name, branch)
+
+            modified_resources.each do |resource|
+              updater.update_resource(resource, ref[:object][:sha], categories)
+            end
+          end
+
+          respond_with(200, true)
+        end
+
+        private
+
+        def tag_resources_for(tx_resources)
+          payload['head_commit']['modified'].each_with_object(Set.new) do |modified, ret|
+            logger.info("processing modified file: #{modified}")
+
+            if tx_resources.include?(modified)
+              ret << tx_resources[modified]
+            end
+          end
+        end
+
+        def l10n_resources_for(tx_resources)
+          payload['head_commit']['modified'].each_with_object(Set.new) do |modified, ret|
+            if tx_resources.include?(modified)
+              logger.info("setting new resource: #{tx_resources[modified].L10N_resource_slug}")
+              ret << tx_resources[modified]
+            end
+          end
+        end
+
+        # finds the resources that were updated in each commit
+        def added_and_modified_resources_for(tx_resources)
+          payload['commits'].each_with_object(Set.new) 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]
+              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?
+              Txgh::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
+
+        def should_process?
+          should_process_branch? && should_process_commit?
+        end
+
+        def should_process_branch?
+          repo.should_process_ref?(branch)
+        end
+
+        def should_process_commit?
+          # return false if 'after' commit sha is all zeroes (indicates branch
+          # has been deleted)
+          !(payload.fetch('after', '') =~ /\A0+\z/)
+        end
+
+      end
+    end
+  end
+end

data/lib/txgh-server/webhooks/github/request_handler.rb

@@ -0,0 +1,113 @@
+require 'json'
+
+module TxghServer
+  module Webhooks
+    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)
+              when 'ping'
+                handle_ping(request, logger)
+              else
+                handle_unexpected
+            end
+          end
+
+          private
+
+          def handle_push(request, logger)
+            klass = TxghServer::Webhooks::Github::PushHandler
+            new(request, logger).handle(klass)
+          end
+
+          def handle_delete(request, logger)
+            klass = TxghServer::Webhooks::Github::DeleteHandler
+            new(request, logger).handle(klass)
+          end
+
+          def handle_ping(request, logger)
+            klass = TxghServer::Webhooks::Github::PingHandler
+            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-server/webhooks/github.rb

@@ -0,0 +1,11 @@
+module TxghServer
+  module Webhooks
+    module Github
+      autoload :DeleteHandler,  'txgh-server/webhooks/github/delete_handler'
+      autoload :Handler,        'txgh-server/webhooks/github/handler'
+      autoload :PingHandler,    'txgh-server/webhooks/github/ping_handler'
+      autoload :PushHandler,    'txgh-server/webhooks/github/push_handler'
+      autoload :RequestHandler, 'txgh-server/webhooks/github/request_handler'
+    end
+  end
+end

data/lib/txgh-server/webhooks/transifex/hook_handler.rb

@@ -0,0 +1,94 @@
+require 'logger'
+
+module TxghServer
+  module Webhooks
+    module Transifex
+      class HookHandler
+        include Txgh::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)
+
+          check_error_response || begin
+            committer = Txgh::ResourceCommitter.new(project, repo, logger)
+            committer.commit_resource(tx_resource, branch, language)
+            respond_with(200, true)
+          end
+        end
+
+        private
+
+        def check_error_response
+          check_supported_language || check_tx_config || check_tx_resource
+        end
+
+        def check_supported_language
+          respond_with(304, true) unless supported_language?
+        end
+
+        def check_tx_config
+          unless tx_config
+            respond_with_error(
+              404, "Could not find configuration for branch '#{branch}'"
+            )
+          end
+        end
+
+        def check_tx_resource
+          unless tx_resource
+            respond_with_error(
+              404, "Could not find resource '#{resource_slug}' in config"
+            )
+          end
+        end
+
+        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
+
+            Txgh::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
+
+        def supported_language?
+          project.supported_language?(language)
+        end
+      end
+    end
+  end
+end

data/lib/txgh-server/webhooks/transifex/request_handler.rb

@@ -0,0 +1,78 @@
+require 'uri'
+
+module TxghServer
+  module Webhooks
+    module Transifex
+      class RequestHandler
+        class << self
+
+          def handle_request(request, logger)
+            new(request, logger).handle(TxghServer::Webhooks::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

data/lib/txgh-server/webhooks/transifex.rb

@@ -0,0 +1,8 @@
+module TxghServer
+  module Webhooks
+    module Transifex
+      autoload :HookHandler,    'txgh-server/webhooks/transifex/hook_handler'
+      autoload :RequestHandler, 'txgh-server/webhooks/transifex/request_handler'
+    end
+  end
+end

data/lib/txgh-server/webhooks.rb

@@ -0,0 +1,6 @@
+module TxghServer
+  module Webhooks
+    autoload :Github,    'txgh-server/webhooks/github'
+    autoload :Transifex, 'txgh-server/webhooks/transifex'
+  end
+end

data/lib/txgh-server/zip_stream_response.rb

@@ -0,0 +1,19 @@
+require 'ext/zipline/output_stream'
+
+module TxghServer
+  class ZipStreamResponse < StreamResponse
+
+    def write_to(stream)
+      Zipline::OutputStream.open(stream) do |zipfile|
+        enum.each do |file_name, contents|
+          zipfile.put_next_entry(file_name, contents.bytesize)
+          zipfile << contents
+        end
+      end
+    end
+
+    def file_extension
+      '.zip'
+    end
+  end
+end

data/lib/txgh-server.rb

@@ -0,0 +1,23 @@
+require 'txgh'
+
+module TxghServer
+  autoload :Application,          'txgh-server/application'
+  autoload :DownloadHandler,      'txgh-server/download_handler'
+
+  # @TODO: refactor/remove
+  autoload :WebhookEndpoints,     'txgh-server/application'
+
+  autoload :GithubRequestAuth,    'txgh-server/github_request_auth'
+  autoload :Response,             'txgh-server/response'
+  autoload :ResponseHelpers,      'txgh-server/response_helpers'
+  autoload :StreamResponse,       'txgh-server/stream_response'
+  autoload :TgzStreamResponse,    'txgh-server/tgz_stream_response'
+  autoload :TransifexRequestAuth, 'txgh-server/transifex_request_auth'
+
+  # @TODO: refactor/remove
+  autoload :TriggerEndpoints,     'txgh-server/application'
+
+  autoload :Triggers,             'txgh-server/triggers'
+  autoload :Webhooks,             'txgh-server/webhooks'
+  autoload :ZipStreamResponse,    'txgh-server/zip_stream_response'
+end