fastlane-plugin-sapfire 1.0.0

data/lib/fastlane/plugin/sapfire/actions/upload_nuget_action.rb

@@ -0,0 +1,95 @@
+require "fastlane/action"
+require_relative "../helper/sapfire_helper"
+
+module Fastlane
+  module Actions
+    class UploadNugetAction < Action
+      def self.run(params)
+        UI.user_error!("Can't find dotnet") unless Helper::SapfireHelper.dotnet_specified?
+
+        dotnet_path = Actions.lane_context[SharedValues::SF_DOTNET_PATH]
+        dotnet_args = get_dotnet_args(params)
+        cmd = "\"#{dotnet_path}\" nuget push #{dotnet_args.join(" ")}"
+
+        UI.command(cmd)
+
+        Open3.popen2(cmd) do |_, stdout, wait_thr|
+          until stdout.eof?
+            stdout.each do |l|
+              line = l.force_encoding("utf-8").chomp
+              puts line
+            end
+          end
+
+          UI.user_error!("NuGet package pushing failed. See the log above.") unless wait_thr.value.success?
+          UI.success("Package has successfully uploaded") if wait_thr.value.success?
+        end
+      end
+
+      def self.description
+        "Pushes a package to the server and publishes it"
+      end
+
+      def self.authors
+        ["CheeryLee"]
+      end
+
+      def self.is_supported?(platform)
+        true
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(
+            key: :api_key,
+            description: "The API key for the server",
+            optional: false,
+            type: String,
+            verify_block: proc do |value|
+              UI.user_error!("The API key for the server must be specified and must not be empty") unless value && !value.empty?
+            end
+          ),
+          FastlaneCore::ConfigItem.new(
+            key: :source,
+            description: "The server URL. NuGet identifies a UNC or local folder source and simply copies the file there instead of pushing it using HTTP",
+            optional: false,
+            type: String
+          ),
+          FastlaneCore::ConfigItem.new(
+            key: :timeout,
+            description: "The timeout for pushing to a server in seconds",
+            optional: true,
+            default_value: 0,
+            type: Integer
+          ),
+          FastlaneCore::ConfigItem.new(
+            key: :path,
+            description: "The file path to the package to be uploaded",
+            optional: false,
+            type: String,
+            verify_block: proc do |value|
+              UI.user_error!("Path to NuGet package is invalid") unless value && !value.empty?
+              UI.user_error!("The provided path doesn't point to NUPKG-file") unless
+                File.exist?(File.expand_path(value)) && value.end_with?(".nupkg")
+            end
+          )
+        ]
+      end
+
+      def self.category
+        :production
+      end
+
+      def self.get_dotnet_args(params)
+        args = []
+
+        args.append(params[:path])
+        args.append("--api-key #{params[:api_key]}")
+        args.append("--source #{params[:source]}")
+        args.append("--timeout #{params[:timeout]}")
+
+        args
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/sapfire/actions_base/msbuild_action_base.rb

@@ -0,0 +1,42 @@
+require "fastlane/action"
+require_relative "../msbuild/runner"
+require_relative "../msbuild/options"
+require_relative "../msbuild/module"
+
+module Fastlane
+  module Actions
+    class MsbuildActionBase < Action
+      def self.run(params)
+        Msbuild.config.params = params
+        Msbuild.config.msbuild_type = Fastlane::Actions.lane_context[SharedValues::SF_MSBUILD_TYPE]
+        Msbuild.config.overwritten_props = overwritten_msbuild_properties
+        msbuild_path = Fastlane::Actions.lane_context[SharedValues::SF_MSBUILD_PATH]
+
+        Msbuild.config.msbuild_path = if Msbuild.config.msbuild_type == Msbuild::MsbuildType::LIBRARY
+                                        "\"#{Fastlane::Actions.lane_context[SharedValues::SF_DOTNET_PATH]}\" \"#{msbuild_path}\""
+                                      else
+                                        "\"#{msbuild_path}\""
+                                      end
+
+        runner = Msbuild::Runner.new
+        runner.run
+      end
+
+      def self.overwritten_msbuild_properties
+        {
+          Configuration: "configuration",
+          Platform: "platform"
+        }
+      end
+
+      def self.available_options
+        rejected_options_array = rejected_options
+        return Msbuild::Options.available_options if rejected_options_array.nil?
+
+        Msbuild::Options.available_options.reject do |option|
+          rejected_options_array.include?(option.key)
+        end
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/sapfire/helper/ms_devcenter_helper.rb

@@ -0,0 +1,292 @@
+module Fastlane
+  module Helper
+    class MsDevCenterHelper
+      HOST = "https://manage.devcenter.microsoft.com".freeze
+      API_VERSION = "v1.0".freeze
+      API_ROOT = "my/applications".freeze
+      REQUEST_HEADERS = {
+        "Accept": "application/json"
+      }.freeze
+      FILE_CHUNK_SIZE = 26_214_400
+      UPLOAD_RETRIES = 3
+
+      def self.upload_blob(url, zip_path, timeout = 0)
+        UI.user_error!("File upload URL need to be provided") if !url.is_a?(String) || url.nil? || url.empty?
+        UI.user_error!("File path is invalid") if !zip_path.is_a?(String) || zip_path.nil? || zip_path.empty?
+
+        expand_path = File.expand_path(zip_path)
+        UI.user_error!("The provided path doesn't point to ZIP file") unless File.exist?(expand_path) && zip_path.end_with?(".zip")
+
+        File.open(expand_path) do |file|
+          block_list = []
+          chunks_count = (file.size.to_f / FILE_CHUNK_SIZE).ceil
+          current_chunk = 1
+
+          until file.eof?
+            bytes = file.read(FILE_CHUNK_SIZE)
+            id = SecureRandom.uuid.delete("-")
+            block_list.append(id)
+            retry_count = 0
+            result = false
+
+            UI.message("Upload chunk [#{current_chunk} / #{chunks_count}]")
+
+            while !result && retry_count < UPLOAD_RETRIES
+              result = upload_block(url, bytes, id, timeout)
+              retry_count += 1
+            end
+
+            UI.user_error!("Uploading failed: some chunks have not been uploaded") unless result
+            current_chunk += 1
+          end
+
+          result = upload_block_list(url, block_list, timeout)
+          UI.user_error!("Uploading failed: block list hasn't been uploaded") unless result
+        end
+      end
+
+      def self.upload_block(url, bytes, id, timeout = 0)
+        headers = {
+          "Content-Length": bytes.length.to_s
+        }
+
+        url_data = parse_upload_url(url)
+        url_data[:query]["comp"] = "block"
+        url_data[:query]["blockid"] = id
+
+        connection = Faraday.new(url_data[:host])
+        response = connection.put(url_data[:path]) do |req|
+          req.headers = headers
+          req.params = url_data[:query]
+          req.body = bytes
+          req.options.timeout = timeout if timeout.positive?
+        end
+
+        return true if response.status == 201
+
+        error = response.body.to_s
+        UI.error("Upload request failed.\nCode: #{response.status}\nError: #{error}")
+        false
+      end
+
+      def self.upload_block_list(url, list, timeout = 0)
+        document = REXML::Document.new
+        document.xml_decl.version = "1.0"
+        document.xml_decl.encoding = "utf-8"
+        block_list = document.add_element("BlockList")
+
+        list.each do |block|
+          block_list.add_element("Latest").text = block
+        end
+
+        url_data = parse_upload_url(url)
+        url_data[:query]["comp"] = "blocklist"
+
+        connection = Faraday.new(url_data[:host])
+        response = connection.put(url_data[:path]) do |req|
+          req.params = url_data[:query]
+          req.body = document.to_s
+          req.options.timeout = timeout if timeout.positive?
+        end
+
+        return true if response.status == 201
+
+        error = response.body.to_s
+        UI.error("Upload block list request failed.\nCode: #{response.status}\nError: #{error}")
+        false
+      end
+
+      def self.get_app_info(app_id, auth_token, timeout = 0)
+        check_app_id(app_id)
+
+        connection = Faraday.new(HOST)
+        response = connection.get("/#{API_VERSION}/#{API_ROOT}/#{app_id}") do |req|
+          req.headers = build_headers(auth_token)
+          req.options.timeout = timeout if timeout.positive?
+        end
+
+        begin
+          data = JSON.parse(response.body)
+          return data if response.status == 200
+
+          UI.user_error!("Request returned the error.\nCode: #{response.status}")
+        rescue StandardError => ex
+          UI.user_error!("Getting app info process failed: #{ex}")
+        end
+      end
+
+      def self.create_submission(app_id, auth_token, timeout = 0)
+        check_app_id(app_id)
+        if non_published_submission?(app_id, auth_token, timeout)
+          UI.user_error!([
+            "There is a pending submission has already been created.",
+            "You need to either proceed it or remove before creating a new one."
+          ].join(" "))
+        end
+
+        connection = Faraday.new(HOST)
+        response = connection.post("/#{API_VERSION}/#{API_ROOT}/#{app_id}/submissions") do |req|
+          req.headers = build_headers(auth_token)
+          req.options.timeout = timeout if timeout.positive?
+        end
+
+        begin
+          data = JSON.parse(response.body)
+          return data if response.status == 201
+
+          code = data["code"]
+          message = data["message"]
+
+          UI.user_error!("Request returned the error.\nCode: #{response.status} #{code}.\nDescription: #{message}")
+        rescue StandardError => ex
+          UI.user_error!("Creating submission process failed: #{ex}")
+        end
+      end
+
+      def self.update_submission(app_id, submission_obj, auth_token, timeout = 0)
+        check_app_id(app_id)
+        UI.user_error!("Submission data object need to be provided") if submission_obj.nil?
+
+        submission_id = submission_obj["id"]
+        connection = Faraday.new(HOST)
+        response = connection.put("/#{API_VERSION}/#{API_ROOT}/#{app_id}/submissions/#{submission_id}") do |req|
+          req.headers = build_headers(auth_token)
+          req.body = submission_obj.to_json
+          req.options.timeout = timeout if timeout.positive?
+        end
+
+        begin
+          data = JSON.parse(response.body)
+          return data if response.status == 200
+
+          UI.user_error!("Request returned the error.\nCode: #{response.status}")
+        rescue StandardError => ex
+          UI.user_error!("Updating submission process failed: #{ex}")
+        end
+      end
+
+      def self.commit_submission(app_id, submission_id, auth_token, timeout = 0)
+        check_app_id(app_id)
+        check_submission_id(submission_id)
+
+        connection = Faraday.new(HOST)
+        response = connection.post("/#{API_VERSION}/#{API_ROOT}/#{app_id}/submissions/#{submission_id}/commit") do |req|
+          req.headers = build_headers(auth_token)
+          req.options.timeout = timeout if timeout.positive?
+        end
+
+        UI.user_error!("Committing submission request returned the error.\nCode: #{response.status}") unless response.status == 202
+      end
+
+      def self.get_submission_status(app_id, submission_id, auth_token, timeout = 0)
+        check_app_id(app_id)
+        check_submission_id(submission_id)
+
+        connection = Faraday.new(HOST)
+        response = connection.get("/#{API_VERSION}/#{API_ROOT}/#{app_id}/submissions/#{submission_id}/status") do |req|
+          req.headers = build_headers(auth_token)
+          req.options.timeout = timeout if timeout.positive?
+        end
+
+        begin
+          data = JSON.parse(response.body)
+          return data if response.status == 200
+
+          UI.user_error!("Request returned the error.\nCode: #{response.status}")
+        rescue StandardError => ex
+          UI.user_error!("Submission status obtaining process failed: #{ex}")
+        end
+      end
+
+      def self.acquire_authorization_token(tenant_id, client_id, client_secret, timeout = 0)
+        body = {
+          client_id: client_id,
+          client_secret: client_secret,
+          grant_type: "client_credentials",
+          resource: HOST
+        }
+        headers = {
+          "Content-Type": "application/x-www-form-urlencoded"
+        }.merge(REQUEST_HEADERS)
+
+        connection = Faraday.new("https://login.microsoftonline.com")
+        response = connection.post("/#{tenant_id}/oauth2/token") do |req|
+          req.headers = headers
+          req.body = body
+          req.options.timeout = timeout if timeout.positive?
+        end
+
+        begin
+          data = JSON.parse(response.body)
+          return data["access_token"] if response.status == 200
+
+          error = data["error"]
+          error_description = data["error_description"]
+
+          UI.user_error!("Request returned the error.\nCode: #{error}.\nDescription: #{error_description}")
+        rescue StandardError => ex
+          UI.user_error!("Authorization failed: #{ex}")
+        end
+      end
+
+      def self.non_published_submission?(app_id, auth_token, timeout = 0)
+        check_app_id(app_id)
+        app_info = get_app_info(app_id, auth_token, timeout)
+        app_info.key?("pendingApplicationSubmission")
+      end
+
+      def self.build_headers(auth_token)
+        {
+          "Authorization": "Bearer #{auth_token}",
+          "Content-Type": "application/json"
+        }.merge(REQUEST_HEADERS)
+      end
+
+      def self.parse_upload_url(url)
+        url = URI.parse(url)
+        query_parts = {}
+        url.query.split("&").each do |x|
+          parts = x.split("=")
+          query_parts[parts[0]] = CGI.unescape(parts[1])
+        end
+
+        {
+          host: "https://#{url.host}",
+          path: url.path,
+          query: query_parts
+        }
+      end
+
+      def self.check_app_id(id)
+        UI.user_error!("App ID need to be provided") if !id.is_a?(String) || id.nil? || id.empty?
+      end
+
+      def self.check_submission_id(id)
+        UI.user_error!("Submission ID need to be provided") if !id.is_a?(String) || id.nil? || id.empty?
+      end
+
+      public_class_method(:upload_blob)
+      public_class_method(:get_app_info)
+      public_class_method(:create_submission)
+      public_class_method(:update_submission)
+      public_class_method(:commit_submission)
+      public_class_method(:get_submission_status)
+      public_class_method(:acquire_authorization_token)
+
+      private_class_method(:upload_block)
+      private_class_method(:upload_block_list)
+      private_class_method(:non_published_submission?)
+      private_class_method(:build_headers)
+      private_class_method(:parse_upload_url)
+      private_class_method(:check_app_id)
+      private_class_method(:check_submission_id)
+
+      private_constant(:HOST)
+      private_constant(:API_VERSION)
+      private_constant(:API_ROOT)
+      private_constant(:REQUEST_HEADERS)
+      private_constant(:FILE_CHUNK_SIZE)
+      private_constant(:UPLOAD_RETRIES)
+    end
+  end
+end

data/lib/fastlane/plugin/sapfire/helper/sapfire_helper.rb

@@ -0,0 +1,55 @@
+module Fastlane
+  module Helper
+    class SapfireHelper
+      def self.dotnet_specified?
+        path = Actions.lane_context[Fastlane::Actions::SharedValues::SF_DOTNET_PATH] || ""
+        path = File.expand_path(path) unless path.empty?
+
+        if path.empty?
+          UI.error("The path to dotnet executable is not specified")
+          return false
+        elsif !File.exist?(path)
+          UI.error("File '#{path}' doesn't exist")
+          return false
+        elsif !path.end_with?("dotnet") && !path.end_with?("dotnet.exe")
+          UI.error("The path to dotnet doesn't point to executable file: #{path}")
+          return false
+        end
+
+        true
+      end
+
+      def self.msbuild_specified?
+        path = Actions.lane_context[Fastlane::Actions::SharedValues::SF_MSBUILD_PATH] || ""
+        path = File.expand_path(path) unless path.empty?
+
+        if path.empty?
+          UI.error("The path to MSBuild executable is not specified")
+          return false
+        elsif !File.exist?(path)
+          UI.error("File '#{path}' doesn't exist")
+          return false
+        elsif !path.end_with?("MSBuild.dll") && !path.end_with?("MSBuild.exe")
+          UI.error("The path to MSBuild doesn't point to executable or DLL file: #{path}")
+          return false
+        end
+
+        true
+      end
+
+      def self.kits_10_location
+        require "win32/registry"
+
+        Win32::Registry::HKEY_LOCAL_MACHINE.open("SOFTWARE\\Wow6432Node\\Microsoft\\Windows Kits\\Installed Roots") do |reg|
+          value = reg["KitsRoot10"]
+          return value.strip
+        end
+      end
+
+      def self.root_plugin_location
+        path = File.join(File.dirname(__dir__), "../../../../")
+        File.expand_path(path)
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/sapfire/msbuild/module.rb

@@ -0,0 +1,34 @@
+require "fastlane/boolean"
+
+module Msbuild
+  class BuildType
+    NONE = 0
+    GENERIC = 1
+    UWP = 2
+    NUGET = 3
+  end
+
+  class MsbuildType
+    EXE = 0
+    LIBRARY = 1
+  end
+
+  class Config
+    attr_accessor :params
+    attr_accessor :msbuild_path
+    attr_accessor :overwritten_props
+    attr_accessor :certificate
+    attr_accessor :certificate_password
+    attr_accessor :certificate_thumbprint
+    attr_accessor :build_type
+    attr_accessor :msbuild_type
+  end
+
+  class << self
+    attr_accessor :config
+  end
+
+  UI = FastlaneCore::UI
+  self.config = Config.new
+  self.config.build_type = BuildType::NONE
+end

data/lib/fastlane/plugin/sapfire/msbuild/options.rb

@@ -0,0 +1,123 @@
+require "fastlane_core/configuration/config_item"
+require_relative "module"
+
+module Msbuild
+  class Options
+    PACKAGE_FORMATS = %w[.appx .appxbundle .appxupload .msix .msixbundle .msixupload].freeze
+
+    def self.available_options
+      return @options if @options
+
+      @options = plain_options
+    end
+
+    def self.plain_options
+      [
+        FastlaneCore::ConfigItem.new(
+          key: :project,
+          description: "Path to the SLN-solution file",
+          optional: false,
+          type: String,
+          verify_block: proc do |value|
+            UI.user_error!("Path to SLN-file is invalid") unless value && !value.empty?
+            UI.user_error!("The provided path doesn't point to SLN-file") unless
+              File.exist?(File.expand_path(value)) && value.end_with?(".sln")
+          end
+        ),
+        FastlaneCore::ConfigItem.new(
+          key: :configuration,
+          description: "Build configuration",
+          optional: false,
+          type: String
+        ),
+        FastlaneCore::ConfigItem.new(
+          key: :platform,
+          description: "Target platform",
+          optional: false,
+          type: String
+        ),
+        FastlaneCore::ConfigItem.new(
+          key: :restore,
+          description: "Restore project prior to build the actual targets",
+          optional: true,
+          default_value: false,
+          type: Fastlane::Boolean
+        ),
+        FastlaneCore::ConfigItem.new(
+          key: :clean,
+          description: "Should the project be cleaned before building it?",
+          optional: true,
+          default_value: false,
+          type: Fastlane::Boolean
+        ),
+        FastlaneCore::ConfigItem.new(
+          key: :appx_output_path,
+          description: "Defines the folder to store the generated package artifacts. Relative path is a root folder where project is located",
+          optional: true,
+          default_value: "",
+          type: String
+        ),
+        FastlaneCore::ConfigItem.new(
+          key: :appx_output_name,
+          description: "Defines the name of the resulting package",
+          optional: true,
+          default_value: "",
+          type: String
+        ),
+        FastlaneCore::ConfigItem.new(
+          key: :appx_bundle_platforms,
+          description: [
+            "Enables you to define the platforms to include in the bundle.",
+            "It's possible to define multiple platforms divided by vertical line, e.g. 'x86|ARM'"
+          ].join("\n"),
+          optional: false,
+          type: String
+        ),
+        FastlaneCore::ConfigItem.new(
+          key: :build_mode,
+          description: "Package build mode. Use `SideloadOnly` for sideloading only or `StoreUpload` for generating the .msixupload/.appxupload file",
+          optional: false,
+          type: String
+        ),
+        FastlaneCore::ConfigItem.new(
+          key: :skip_codesigning,
+          description: "Build without package signing",
+          optional: true,
+          default_value: false,
+          type: Fastlane::Boolean
+        ),
+        FastlaneCore::ConfigItem.new(
+          key: :jobs,
+          description: [
+            "A number of concurrent processes to use when building.",
+            "Set it to -1 if you want to use up to the number of processors in the computer"
+          ].join("\n"),
+          optional: true,
+          default_value: 1,
+          type: Integer,
+          verify_block: proc do |value|
+            UI.important("A number of parallel jobs can't equals to zero. Using default value.") if value.zero?
+          end
+        ),
+        FastlaneCore::ConfigItem.new(
+          key: :properties,
+          description: "A hash of project properties to be set up, where the key is a property name and the value is it's value",
+          optional: true,
+          default_value: {},
+          type: Hash,
+          verify_block: proc do |value|
+            counter = 0
+
+            value.each do |key, _|
+              UI.user_error!("Item #{counter}: key type must be Symbol") unless key.is_a?(Symbol)
+              counter += 1
+            end
+          end
+        )
+      ]
+    end
+
+    public_class_method(:available_options)
+    private_class_method(:plain_options)
+  end
+end