carthage_remote_cache 0.0.2

data/lib/carthage_dependency.rb

@@ -0,0 +1,65 @@
+class CarthageDependency
+
+    class << self
+        # Parses Cartfile.resolved dependency entry, e.g.
+        #   github "CocoaLumberjack/CocoaLumberjack" "3.2.1"
+        def parse_cartfile_resolved_line(line)
+            line.strip!
+            matches = line.match(/^(\w+)\s+\"([^\"]+)\"(\s+\"([^\"]+)\")$/)
+            return nil if matches.nil?
+            if matches.length == 5
+                CarthageDependency.new(type: matches[1], repository: matches[2], version: matches[4])
+            else
+                nil
+            end
+        end
+    end
+
+    attr_reader :type, :repository, :version
+
+    def initialize(args)
+        @type = args[:type]
+        @repository = args[:repository]
+        @version = args[:version]
+    end
+
+    # Since one Cartfile.resolved entry may produce multiple differently named frameworks,
+    # this is an entry point to identifying a framework name.
+    def guessed_framework_basename
+        case @type
+        when "github"
+            repository.split("/").last
+        else
+            raise "Determining version_filename from #{@type} dependency is not yet supported"
+        end
+    end
+
+    def version_filename
+        ".#{guessed_framework_basename}.version"
+    end
+
+    def version_filepath
+        File.join(CARTHAGE_BUILD_DIR, version_filename)
+    end
+
+    def validate_version_file(version_file)
+        raise OutdatedFrameworkBuildError.new, version_validation_message(version_file) if @version != version_file.version
+    end
+
+    def to_s
+        "#{@type} \"#{@repository}\" \"#{@version}\""
+    end
+
+    private
+
+    def version_validation_message(version_file)
+        <<~EOS
+            Outdated version of '#{guessed_framework_basename}' framework detected:
+                Expected version '#{@version}'
+                Found version '#{version_file.version}'
+
+            Please run `carthage bootstrap` to build frameworks.
+        EOS
+    end
+
+end

data/lib/carthage_remote_cache.rb

@@ -0,0 +1,13 @@
+lib = File.expand_path("..", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+require 'api'
+require 'carthage_archive'
+require 'carthage_dependency'
+require 'constants'
+require 'configuration'
+require 'errors'
+require 'log'
+require 'networking'
+require 'utils'
+require 'version_file'

data/lib/commands/download_command.rb

@@ -0,0 +1,67 @@
+require 'concurrent'
+
+class DownloadCommand
+
+    def initialize(options)
+        @options = options
+        @config = Configuration.new
+        @networking = Networking.new(@config)
+        @api = API.new(@networking, options)
+    end
+
+    def run
+        pool = Concurrent::FixedThreadPool.new(THREAD_POOL_SIZE)
+
+        @number_of_downloaded_archives = 0
+        @number_of_skipped_archives = 0
+        errors = Concurrent::Array.new
+
+        for carthage_dependency in @config.carthage_dependencies
+            pool.post(carthage_dependency) do |carthage_dependency|
+                begin
+                    download(carthage_dependency)
+                rescue => e
+                    errors << e
+                end
+            end
+        end
+
+        pool.shutdown
+        pool.wait_for_termination
+
+        if errors.count > 0
+            raise MultipleErrorsError.new(errors)
+        else
+            puts "Downloaded and extracted #{@number_of_downloaded_archives} archives, skipped #{@number_of_skipped_archives} archives."
+        end
+    end
+
+    private
+
+    def download(carthage_dependency)
+        local_version_file = if File.exist?(carthage_dependency.version_filepath)
+            VersionFile.new(carthage_dependency.version_filepath)
+        else
+            nil
+        end
+
+        if !local_version_file.nil? && @api.version_file_matches_server?(carthage_dependency, local_version_file)
+            $LOG.debug("Version file #{local_version_file.path} matches server version, skipping download")
+            @number_of_skipped_archives += local_version_file.number_of_frameworks
+            return
+        end
+
+        version_file = @networking.download_version_file(carthage_dependency)
+        raise "Version file #{carthage_dependency.version_filename} is not present on the server, please run `carthagerc upload` first" if version_file.nil?
+
+        version_file.frameworks_by_platform.each do |platform, framework_names|
+            for framework_name in framework_names do
+                archive = @api.download_and_unpack_archive(carthage_dependency, framework_name, platform)
+                raise "Failed to download framework #{carthage_dependency} – #{framework_name} (#{platform}). Please `upload` the framework first." if archive.nil?
+                @number_of_downloaded_archives += 1
+            end
+        end
+        version_file.move_to_build_dir
+    end
+
+end

data/lib/commands/init_command.rb

@@ -0,0 +1,26 @@
+class InitCommand
+
+    def initialize(options)
+        @options = options
+    end
+
+    def run
+        path = File.join(Dir.pwd, CARTRCFILE)
+        if File.exist?(path)
+            raise "File #{path} already exists"
+        else
+            File.write(path, file_contents)
+        end
+    end
+
+    private
+
+    def file_contents
+        <<~EOS
+            Configuration.setup do |c|
+                c.server = "http://localhost:#{SERVER_DEFAULT_PORT}/"
+            end
+        EOS
+    end
+
+end

data/lib/commands/server_command.rb

@@ -0,0 +1,16 @@
+class ServerCommand
+
+    def initialize(options)
+        @options = options
+    end
+
+    def run
+        ENV['RACK_ENV'] = 'production'
+        require 'server/server_app'
+        Rack::Handler::WEBrick.run(
+            Sinatra::Application,
+            :Port => @options[:server_port]
+        )
+    end
+
+end

data/lib/commands/upload_command.rb

@@ -0,0 +1,63 @@
+require 'concurrent'
+
+class UploadCommand
+
+    def initialize(options)
+        @config = Configuration.new
+        @networking = Networking.new(@config)
+        @api = API.new(@networking, options)
+    end
+
+    def run
+        pool = Concurrent::FixedThreadPool.new(THREAD_POOL_SIZE)
+
+        $LOG.debug("Will upload frameworks: #{@config.all_framework_names}")
+
+        @number_of_uploaded_archives = 0
+        @number_of_skipped_archives = 0
+        errors = Concurrent::Array.new
+
+        for carthage_dependency in @config.carthage_dependencies
+            pool.post(carthage_dependency) do |carthage_dependency|
+                begin
+                    upload(carthage_dependency)
+                rescue => e
+                    errors << e
+                end
+            end
+        end
+
+        pool.shutdown
+        pool.wait_for_termination
+
+        if errors.count > 0
+            raise MultipleErrorsError.new(errors)
+        else
+            puts "Uploaded #{@number_of_uploaded_archives} archives, skipped #{@number_of_skipped_archives}."
+        end
+    end
+
+    private
+
+    def upload(carthage_dependency)
+        version_file = VersionFile.new(carthage_dependency.version_filepath)
+
+        carthage_dependency.validate_version_file(version_file)
+
+        if @api.version_file_matches_server?(carthage_dependency, version_file)
+            $LOG.debug("Version file #{version_file.path} matches server version, skipping upload")
+            @number_of_skipped_archives += version_file.number_of_frameworks
+            return
+        end
+
+        @networking.upload_version_file(carthage_dependency)
+
+        version_file.frameworks_by_platform.each do |platform, framework_names|
+            for framework_name in framework_names
+                @api.create_and_upload_archive(carthage_dependency, framework_name, platform)
+                @number_of_uploaded_archives += 1
+            end
+        end
+    end
+
+end

data/lib/commands.rb

@@ -0,0 +1,7 @@
+lib = File.expand_path("..", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+require 'commands/download_command'
+require 'commands/init_command'
+require 'commands/server_command'
+require 'commands/upload_command'

data/lib/configuration.rb

@@ -0,0 +1,81 @@
+require 'uri'
+
+class Configuration
+
+    class UserConfig
+        attr_accessor :server
+    end
+
+    @@user_config = UserConfig.new
+
+    def self.setup
+        yield(@@user_config)
+    end
+
+    attr_reader :xcodebuild_version, :swift_version, :carthage_dependencies, :server_uri
+
+    def initialize
+        initialize_env
+        initialize_cartrcfile
+    end
+
+    def all_framework_names
+        version_files.flat_map { |vf| vf.framework_names }.uniq.sort
+    end
+
+    def to_s
+        <<~EOS
+            Xcodebuild: #{@xcodebuild_version}
+            ---
+            Swift: #{@swift_version}
+            ---
+            Server: #{@server_uri.to_s}
+            ---
+            Cartfile.resolved:
+            #{@carthage_dependencies.join("\n")}
+            ---
+            Local Build Frameworks:
+            #{framework_names_with_platforms.join("\n")}
+        EOS
+    end
+
+    private
+
+    def initialize_env
+        xcodebuild_raw_version = sh("xcodebuild -version")
+        @xcodebuild_version = xcodebuild_raw_version[/Build version (.*)$/, 1]
+        raise "Could not parse build version from '#{xcodebuild_raw_version}'" if @xcodebuild_version.nil?
+
+        swift_raw_version = sh("swift -version")
+        @swift_version = swift_raw_version[/Apple Swift version (.*) \(/, 1]
+        raise "Could not parse swift version from '#{raw_swift_version}'" if @swift_version.nil?
+
+        raise "Misssing #{CARTFILE_RESOLVED}" unless File.exist?(CARTFILE_RESOLVED)
+        @carthage_dependencies = File.readlines(CARTFILE_RESOLVED)
+            .map { |line| CarthageDependency.parse_cartfile_resolved_line(line) }
+            .compact
+    end
+
+    def initialize_cartrcfile
+        raise "Configuration file #{CARTRCFILE} was not found, consider creating one by running `carthagerc init`" unless File.exist?(CARTRCFILE)
+
+        # Populate class variable @@user_config.
+        load File.join(Dir.pwd, CARTRCFILE)
+
+        raise "Missing 'server' configuration in #{CARTRCFILE}" if @@user_config.server.nil? || @@user_config.server.empty?
+        @server_uri = URI.parse(@@user_config.server)
+    end
+
+    def framework_names_with_platforms
+        version_files.flat_map do |vf|
+            vf.platforms_by_framework.flat_map do |framework_name, platforms|
+                "#{framework_name} #{vf.version} #{platforms}"
+            end
+        end
+    end
+
+    def version_files
+        @carthage_dependencies.map { |d| VersionFile.new(d.version_filepath) }
+    end
+
+end

data/lib/constants.rb

@@ -0,0 +1,8 @@
+CARTHAGE_DIR = 'Carthage'
+CARTHAGE_BUILD_DIR = File.join(CARTHAGE_DIR, 'Build')
+CARTFILE_RESOLVED = 'Cartfile.resolved'
+CARTRCFILE =  'Cartrcfile'
+THREAD_POOL_SIZE = 8
+
+SERVER_DEFAULT_PORT = 9292
+SERVER_CACHE_DIR = File.join(Dir.home, '.carthage-remote-cache')

data/lib/errors.rb

@@ -0,0 +1,13 @@
+class MultipleErrorsError < StandardError
+
+    def initialize(errors)
+        @errors = errors
+    end
+
+    def message
+        @errors.map { |e| e.message }.join("\n")
+    end
+
+end
+
+class OutdatedFrameworkBuildError < StandardError; end

data/lib/log.rb

@@ -0,0 +1,4 @@
+require 'logger'
+
+$LOG = Logger.new(STDOUT)
+$LOG.level = Logger::INFO

data/lib/networking.rb

@@ -0,0 +1,96 @@
+require 'rest-client'
+require 'uri'
+
+class Networking
+
+    def initialize(config)
+        @config = config
+    end
+
+    # Version Files
+
+    def download_version_file(carthage_dependency)
+        url = new_version_file_url(carthage_dependency)
+        $LOG.debug("Downloading version file from #{url}")
+        version_file = RestClient.get(url) do |response, request, result|
+            if response.code == 200
+                File.write(carthage_dependency.version_filename, response.to_s)
+                VersionFile.new(carthage_dependency.version_filename)
+            else
+                nil
+            end
+        end
+        version_file
+    end
+
+    def upload_version_file(carthage_dependency)
+        url = new_version_file_url(carthage_dependency)
+        $LOG.debug("Uploading #{carthage_dependency.version_filename}")
+        RestClient.post(url, :version_file => File.new(carthage_dependency.version_filepath))
+    end
+
+    #  Archives
+
+    def download_framework_archive(carthage_dependency, framework_name, platform)
+        url = new_framework_url(carthage_dependency, framework_name, platform)
+        $LOG.debug("Downloading framework from #{url}")
+        archive = RestClient.get(url) do |response, request, result|
+            if response.code == 200
+                archive = CarthageArchive.new(framework_name, platform)
+                File.write(archive.archive_path, response.to_s)
+                archive
+            else
+                nil
+            end
+        end
+        archive
+    end
+
+    def upload_framework_archive(zipfile_name, carthage_dependency, framework_name, platform)
+        url = new_framework_url(carthage_dependency, framework_name, platform)
+        $LOG.debug("Uploading framework to #{url}")
+        RestClient.post(url, :framework_file => File.new(zipfile_name))
+    end
+
+    private
+
+    def new_version_file_url(carthage_dependency)
+        new_server_url([
+            'versions',
+            @config.xcodebuild_version,
+            @config.swift_version,
+            carthage_dependency.guessed_framework_basename,
+            carthage_dependency.version,
+            carthage_dependency.version_filename,
+        ])
+    end
+
+    def new_framework_url(carthage_dependency, framework_name, platform)
+        new_server_url([
+            'frameworks',
+            @config.xcodebuild_version,
+            @config.swift_version,
+            carthage_dependency.guessed_framework_basename,
+            carthage_dependency.version,
+            framework_name,
+            platform_to_api_string(platform),
+        ])
+    end
+
+    def new_server_url(path_slices)
+        sanitized_path_slices = path_slices.map { |p| sanitized(p) }
+        uri = URI::HTTP.build(
+            :scheme => @config.server_uri.scheme,
+            :host => @config.server_uri.host,
+            :port => @config.server_uri.port,
+            :path => '/' + sanitized_path_slices.join('/')
+        )
+        uri.to_s
+    end
+
+    # Mangle identifiers for URL paths.
+    def sanitized(input)
+        input.gsub(/\//, '_')
+    end
+
+end

data/lib/server/config.ru

@@ -0,0 +1,6 @@
+require 'rubygems'
+require 'bundler'
+Bundler.require
+
+require './server_app.rb'
+run Sinatra::Application

data/lib/server/server_app.rb

@@ -0,0 +1,93 @@
+require 'sinatra'
+require 'fileutils'
+require 'carthage_remote_cache'
+
+get '/' do
+    "Welcome to carthage_remote_cache"
+end
+
+versions_path = '/versions/:xcodebuild_version/:swift_version/:dependency_name/:version/:version_filename'
+frameworks_path = '/frameworks/:xcodebuild_version/:swift_version/:dependency_name/:version/:framework_name/:platform'
+
+get versions_path do
+    dirname = params_to_framework_dir(params)
+    filename = params[:version_filename]
+    filepath = File.join(dirname, filename)
+
+    if File.exist?(filepath)
+        status(200)
+        send_file(filepath)
+    else
+        status(404)
+    end
+end
+
+post versions_path do
+    dirname = params_to_framework_dir(params)
+    filename = params[:version_filename]
+
+    source_file = params[:version_file][:tempfile]
+    target_filename = File.join(dirname, filename)
+
+    FileUtils.mkdir_p(dirname) unless File.directory?(dirname)
+    File.delete(target_filename) if File.exist?(target_filename)
+
+    $LOG.info("Writing #{target_filename}")
+    File.open(target_filename, 'wb') do |target_file|
+        target_file.write(source_file.read)
+    end
+
+    status(200)
+end
+
+# Check whether framework archive is already cached.
+head frameworks_path do
+    dirname = params_to_framework_dir(params)
+    archive = CarthageArchive.new(params[:framework_name], params[:platform].to_sym)
+    filename = File.join(dirname, archive.archive_filename)
+
+    if File.exist?(filename)
+        status(200)
+    else
+        status(404)
+    end
+end
+
+# Retrieve .zip framework archive.
+get frameworks_path do
+    dirname = params_to_framework_dir(params)
+    archive = CarthageArchive.new(params[:framework_name], params[:platform].to_sym)
+    filename = File.join(dirname, archive.archive_filename)
+
+    if File.exist?(filename)
+        status(200)
+        send_file(filename)
+    else
+        status(404)
+    end
+end
+
+# Upload framework archive. Overwrites already cached archive if exists.
+post frameworks_path do
+    filename = params[:framework_file][:filename]
+    source_file = params[:framework_file][:tempfile]
+
+    dirname = params_to_framework_dir(params)
+    target_filename = File.join(dirname, filename)
+
+    FileUtils.mkdir_p(dirname) unless File.directory?(dirname)
+    File.delete(target_filename) if File.exist?(target_filename)
+
+    $LOG.info("Writing: #{target_filename}")
+    File.open(target_filename, 'wb') do |target_file|
+        target_file.write(source_file.read)
+    end
+
+    status(200)
+end
+
+private
+
+def params_to_framework_dir(params)
+    File.join(SERVER_CACHE_DIR, params[:xcodebuild_version], params[:swift_version], params[:dependency_name], params[:version])
+end

data/lib/utils.rb

@@ -0,0 +1,62 @@
+def sh(cmd)
+    output = `#{cmd}`
+    bail("Command `#{cmd}` failed!") unless $?.success?
+    output.strip
+end
+
+# Exits Ruby process, only to be called:
+# 1. If sh / system calls fail
+# 2. From top level `carthagerc` script
+def bail(message, code = 1)
+    $stderr.puts(message.strip + "\n")
+    Process.exit(code)
+end
+
+# Quote command line arguments with double quotes.
+# Useful for file paths with spaces.
+def quote(input)
+    if input.is_a? String
+        if input.empty?
+            ''
+        else
+            '"' + input + '"'
+        end
+    elsif input.is_a? Array
+        input
+            .map { |e| quote(e) }
+            .select { |e| !e.empty? }
+            .join(' ')
+    else
+        raise "Unsupported type #{input}"
+    end
+end
+
+def platform_to_api_string(platform)
+    case platform
+    when :iOS
+        'iOS'
+    when :macOS
+        'macOS'
+    when :tvOS
+        'tvOS'
+    when :watchOS
+        'watchOS'
+    else
+        raise "Unrecognized platform #{platform.inspect}"
+    end
+end
+
+def platform_to_carthage_dir_string(platform)
+    case platform
+    when :iOS
+        'iOS'
+    when :macOS
+        'Mac'
+    when :tvOS
+        'tvOS'
+    when :watchOS
+        'watchOS'
+    else
+        raise "Unrecognized platform #{platform.inspect}"
+    end
+end