dpl 1.8.48.travis.2486.5 → 1.9.0

data/lib/dpl/provider/azure_webapps.rb

@@ -1,48 +0,0 @@
-module DPL
-  class Provider
-    class AzureWebApps < Provider
-      def config
-        {
-          "username"     => options[:username] || context.env['AZURE_WA_USERNAME'],
-          "password"     => options[:password] || context.env['AZURE_WA_PASSWORD'],
-          "site"         => options[:site] || context.env['AZURE_WA_SITE'],
-          "slot"         => options[:slot] || context.env['AZURE_WA_SLOT']
-        }
-      end
-
-      def git_target
-        "https://#{config['username']}:#{config['password']}@#{config['slot'] || config['site']}.scm.azurewebsites.net:443/#{config['site']}.git"
-      end
-
-      def needs_key?
-        false
-      end
-
-      def check_app
-      end
-
-      def check_auth
-        error "missing Azure Git Deployment username" unless config['username']
-        error "missing Azure Git Deployment password" unless config['password']
-        error "missing Azure Web App name" unless config['site']
-      end
-
-      def push_app
-        log "Deploying to Azure Web App '#{config['slot'] || config['site']}'"
-
-        if !!options[:skip_cleanup]
-          log "Skipping Cleanup"
-          context.shell "git checkout HEAD"
-          context.shell "git add . --all --force"
-          context.shell "git commit -m \"Skip Cleanup Commit\""
-        end
-
-        if !!options[:verbose]
-          context.shell "git push --force --quiet #{git_target} HEAD:refs/heads/master"
-        else
-          context.shell "git push --force --quiet #{git_target} HEAD:refs/heads/master > /dev/null 2>&1"
-        end
-      end
-    end
-  end
-end

data/lib/dpl/provider/bintray.rb

@@ -1,509 +0,0 @@
-require 'json'
-require 'net/http'
-require "uri"
-require 'find'
-
-module DPL
-  class Provider
-    class Bintray < Provider
-      def check_auth
-      end
-
-      def needs_key?
-        false
-      end
-
-      attr_accessor :test_mode
-      attr_reader :user
-      attr_reader :key
-      attr_reader :file
-      attr_reader :passphrase
-      attr_reader :url
-      attr_reader :dry_run
-      attr_reader :descriptor
-
-      def initialize(*args)
-        super(*args)
-        @test_mode = false
-        @user = options[:user]
-        @key = options[:key]
-        @url = options[:url]
-        @file = options[:file]
-        @passphrase = options[:passphrase]
-        @dry_run = options[:dry_run]
-
-        if @user.nil?
-          abort("The 'user' argument is required")
-        end
-        if @key.nil?
-          abort("The 'key' argument is required")
-        end
-        if @file.nil?
-          abort("The 'file' argument is required")
-        end
-        if @url.nil?
-          @url = 'https://api.bintray.com'
-        end
-        if @dry_run.nil?
-          @dry_run = false
-        end
-      end
-
-      def read_descriptor
-        log "Reading descriptor file: #{file}"
-        @descriptor = JSON.parse(File.read(file))
-      end
-
-      def descriptor=(json)
-        @descriptor = JSON.parse(json)
-      end
-
-      def head_request(path)
-        url = URI.parse(self.url)
-        req = Net::HTTP::Head.new(path)
-        req.basic_auth user, key
-
-        sock = Net::HTTP.new(url.host, url.port)
-        sock.use_ssl = true
-        res = sock.start {|http| http.request(req) }
-
-        return res
-      end
-
-      def post_request(path, body)
-        req = Net::HTTP::Post.new(path)
-        req.add_field('Content-Type', 'application/json')
-        req.basic_auth user, key
-        if !body.nil?
-          req.body = body.to_json
-        end
-
-        url = URI.parse(self.url)
-        sock = Net::HTTP.new(url.host, url.port)
-        sock.use_ssl = true
-        res = sock.start {|http| http.request(req) }
-        return res
-      end
-
-      def put_file_request(local_file_path, upload_path, matrix_params)
-        url = URI.parse(self.url)
-
-        file = File.open(local_file_path, 'rb')
-        data = file.read()
-        http = Net::HTTP.new(url.host, url.port)
-        http.use_ssl = true
-
-        params = ''
-        if !matrix_params.nil?
-          matrix_params.each do |key, val|
-            params << ";#{key}=#{val}"
-          end
-          upload_path << params
-        end
-
-        request = Net::HTTP::Put.new("#{upload_path}")
-        request.basic_auth user, key
-        request.body = data
-
-        return http.request(request)
-      end
-
-      def upload_file(artifact)
-        log "Uploading file '#{artifact.local_path}' to #{artifact.upload_path}"
-
-        if dry_run
-          return
-        end
-
-        package = descriptor["package"]
-        version = descriptor["version"]
-        package_name = package["name"]
-        subject = package["subject"]
-        repo = package["repo"]
-        version_name = version["name"]
-
-        path = "/content/#{subject}/#{repo}/#{package_name}/#{version_name}/#{artifact.upload_path}"
-        res = put_file_request(artifact.local_path, path, artifact.matrix_params)
-        log_bintray_response(res)
-      end
-
-      def package_exists_path
-        package = descriptor["package"]
-        subject = package["subject"]
-        name = package["name"]
-        repo = package["repo"]
-        return "/packages/#{subject}/#{repo}/#{name}"
-      end
-
-      def package_exists?
-        path = package_exists_path
-        if !dry_run
-          res = head_request(path)
-          code = res.code.to_i
-        else
-          code = 404
-        end
-
-        if code == 404
-          return false
-        end
-        if code == 201 || code == 200
-          return true
-        end
-        name = descriptor["package"]["name"]
-        abort("Unexpected HTTP response code #{code} returned from Bintray while checking if package '#{name}' exists. " +
-                  "Response message: #{res.message}")
-      end
-
-      def version_exists_path
-        package = descriptor["package"]
-        version = descriptor["version"]
-        package_name = package["name"]
-        subject = package["subject"]
-        repo = package["repo"]
-        version_name = version["name"]
-
-        return "/packages/#{subject}/#{repo}/#{package_name}/versions/#{version_name}"
-      end
-
-      def version_exists?
-        path = version_exists_path
-        if !dry_run
-          res = head_request(path)
-          code = res.code.to_i
-        else
-          code = 404
-        end
-
-        if code == 404
-          return false
-        end
-        if code == 201 || code == 200
-          return true
-        end
-        version_name = descriptor["version"]["name"]
-        abort("Unexpected HTTP response code #{code} returned from Bintray while checking if version '#{version_name}' exists. " +
-                  "Response message: #{res.message}")
-      end
-
-      def create_package
-        package = descriptor["package"]
-        repo = package["repo"]
-        body = {}
-
-        add_to_map(body, package, "name")
-        add_to_map(body, package, "desc")
-        add_to_map(body, package, "licenses")
-        add_to_map(body, package, "labels")
-        add_to_map(body, package, "vcs_url")
-        add_to_map(body, package, "website_url")
-        add_to_map(body, package, "issue_tracker_url")
-        add_to_map(body, package, "public_download_numbers")
-        add_to_map(body, package, "public_stats")
-
-        subject = package["subject"]
-        package_name = package["name"]
-        log "Creating package '#{package_name}'..."
-
-        path = "/packages/#{subject}/#{repo}"
-        if !dry_run
-          res = post_request(path, body)
-          log_bintray_response(res)
-          code = res.code.to_i
-        else
-          code = 200
-        end
-
-        if !test_mode
-          if code == 201 || code == 200
-            add_package_attributes
-          end
-        end
-        RequestDetails.new(path, body)
-      end
-
-      def add_package_attributes
-        package = descriptor["package"]
-        repo = package["repo"]
-        subject = package["subject"]
-        package_name = package["name"]
-        attributes = package["attributes"]
-        path = nil
-        if !attributes.nil?
-          log "Adding attributes for package '#{package_name}'..."
-          path = "/packages/#{subject}/#{repo}/#{package_name}/attributes"
-          if !dry_run
-            res = post_request(path, attributes)
-            log_bintray_response(res)
-          end
-        end
-        RequestDetails.new(path, attributes)
-      end
-
-      def create_version
-        package = descriptor["package"]
-        version = descriptor["version"]
-        repo = package["repo"]
-        body = {}
-
-        add_to_map(body, version, "name")
-        add_to_map(body, version, "desc")
-        add_to_map(body, version, "released")
-        add_to_map(body, version, "vcs_tag")
-        add_to_map(body, version, "github_release_notes_file")
-        add_to_map(body, version, "github_use_tag_release_notes")
-        add_to_map(body, version, "attributes")
-
-        package_name = package["name"]
-        subject = package["subject"]
-        version_name = version["name"]
-        log "Creating version '#{version_name}'..."
-
-        path = "/packages/#{subject}/#{repo}/#{package_name}/versions"
-        if !dry_run
-          res = post_request(path, body)
-          log_bintray_response(res)
-          code = res.code.to_i
-        else
-          code = 200
-        end
-
-        if !test_mode
-          if code == 201 || code == 200
-            add_version_attributes
-          end
-        end
-        RequestDetails.new(path, body)
-      end
-
-      def add_version_attributes
-        package = descriptor["package"]
-        package_name = package["name"]
-        subject = package["subject"]
-        version = descriptor["version"]
-        version_name = version["name"]
-        repo = package["repo"]
-        attributes = version["attributes"]
-        path = nil
-        if !attributes.nil?
-          log "Adding attributes for version '#{version_name}'..."
-          path = "/packages/#{subject}/#{repo}/#{package_name}/versions/#{version_name}/attributes"
-          if !dry_run
-            res = post_request(path, attributes)
-            log_bintray_response(res)
-          end
-        end
-        RequestDetails.new(path, attributes)
-      end
-
-      def check_and_create_package
-        if !package_exists?
-          create_package
-        end
-      end
-
-      def check_and_create_version
-        if !version_exists?
-          create_version
-        end
-      end
-
-      def upload_files
-        files = files_to_upload
-
-        files.each do |key, artifact|
-          upload_file(artifact)
-        end
-      end
-
-      def publish_version
-        publish = descriptor["publish"]
-        if publish
-          package = descriptor["package"]
-          version = descriptor["version"]
-          repo = package["repo"]
-          package_name = package["name"]
-          subject = package["subject"]
-          version_name = version["name"]
-
-          log "Publishing version '#{version_name}' of package '#{package_name}'..."
-          path = "/content/#{subject}/#{repo}/#{package_name}/#{version_name}/publish"
-          if !dry_run
-            res = post_request(path, nil)
-            log_bintray_response(res)
-          end
-        end
-        RequestDetails.new(path, nil)
-      end
-
-      def gpg_sign_version
-        version = descriptor["version"]
-        gpg_sign = version["gpgSign"]
-        if gpg_sign
-          package = descriptor["package"]
-          repo = package["repo"]
-          package_name = package["name"]
-          subject = package["subject"]
-          version_name = version["name"]
-
-          body = nil
-          if !passphrase.nil?
-            log "Signing version with no passphrase..."
-            body = {}
-            body["passphrase"] = passphrase
-          else
-            log "Signing version with passphrase..."
-          end
-
-          path = "/gpg/#{subject}/#{repo}/#{package_name}/versions/#{version_name}"
-          if !dry_run
-            res = post_request(path, body)
-            log_bintray_response(res)
-          end
-          RequestDetails.new(path, body)
-        end
-      end
-
-      # Get the root path from which to start collecting files to be
-      # uploaded to Bintray.
-      def root_path(str)
-        index = str.index('(')
-        path = nil
-        if index.nil? || str.start_with?('(')
-          path = str
-        else
-          path = str[0, index]
-        end
-
-        if !test_mode && !File.exist?(path)
-          log "Warning: Path: #{path} does not exist."
-          return nil
-        end
-        return path
-      end
-
-      # Fills a map with Artifact objects which match
-      # the include pattern and do not match the exclude pattern.
-      # The artifacts are files collected from the file system.
-      def fill_files_map(map, include_pattern, exclude_pattern, upload_pattern, matrix_params)
-        # Get the root path from which to start collecting the files.
-        root_path = root_path(include_pattern)
-        if root_path.nil?
-          return
-        end
-
-        # Start scanning the root path recursively.
-        Find.find(root_path) do |path|
-          add_if_matches(map, path, include_pattern, exclude_pattern, upload_pattern, matrix_params)
-        end
-      end
-
-      def add_if_matches(map, path, include_pattern, exclude_pattern, upload_pattern, matrix_params)
-        res = path.match(/#{include_pattern}/)
-
-        # If the file matches the include pattern and it is not a directory.
-        # In case test_mode is set, we do not check if the file exists.
-        if !res.nil? && (test_mode || File.file?(path))
-          # If the file does not match the exclude pattern.
-          if exclude_pattern.nil? || exclude_pattern.empty? || !path.match(/#{exclude_pattern}/)
-            # Using the capturing groups in the include pattern, replace the $1, $2, ...
-            # in the upload pattern.
-            groups = res.captures
-            replaced_upload_pattern = upload_pattern
-            for i in 0..groups.size-1
-              replaced_upload_pattern = replaced_upload_pattern.gsub("$#{i+1}", groups[i])
-            end
-            map[path] = Artifact.new(path, replaced_upload_pattern, matrix_params)
-          end
-        end
-      end
-
-      # Returns a map containing Artifact objects.
-      # The map contains the files to be uploaded to Bintray.
-      def files_to_upload
-        upload_files = Hash.new()
-        files = descriptor["files"]
-        if files.nil?
-          return upload_files
-        end
-
-        files.each { |patterns|
-          fill_files_map(
-              upload_files,
-              patterns["includePattern"],
-              patterns["excludePattern"],
-              patterns["uploadPattern"],
-              patterns["matrixParams"])
-        }
-
-        return upload_files
-      end
-
-      def deploy
-        read_descriptor
-        check_and_create_package
-        check_and_create_version
-        upload_files
-        gpg_sign_version
-        publish_version
-      end
-
-      # Copies a key from one map to another, if the key exists there.
-      def add_to_map(to_map, from_map, key)
-        if !from_map[key].nil?
-          to_map[key] = from_map[key]
-        end
-      end
-
-      def log_bintray_response(res)
-        msg = ''
-        if !res.body.nil?
-          begin
-            response = JSON.parse(res.body)
-            msg = response["message"]
-          rescue
-          end
-        end
-
-        log "Bintray response: #{res.code.to_i} #{res.message}. #{msg}"
-      end
-
-      def log(msg)
-        puts "[Bintray Upload] #{msg}"
-      end
-
-      # This class represents an artifact (file) to be uploaded to Bintray.
-      class Artifact
-        def initialize(local_path, upload_path, matrix_params)
-          @local_path = local_path
-          @upload_path = upload_path
-          @matrix_params = matrix_params
-        end
-
-        def hash
-          return @localPath.hash
-        end
-
-        def eql?(other)
-          @localPath == other.local_path
-        end
-
-        attr_reader :local_path
-        attr_reader :upload_path
-        attr_reader :matrix_params
-      end
-
-      # Used to return the path and body of REST requests sent to Bintray.
-      # Used for testing.
-      class RequestDetails
-        def initialize(path, body)
-          @path = path
-          @body = body
-        end
-
-        attr_reader :path
-        attr_reader :body
-      end
-    end
-  end
-end