package_cloud 0.0.3 → 0.3.15

data/lib/package_cloud/cli.rb

@@ -1,22 +1,55 @@
-require "colorize"
 require "thor"
+require "logger"
+require "benchmark"
 
 module PackageCloud
-  class CLI < Thor
-    option "config"
-    option "url"
-    desc "push user/repo /path/to/package",
-         "push package to repository"
-    def push(repo, package_file)
-      config = ConfigFile.new(options[:config] || "~/.packagecloud",
-                              options[:url] || "packagecloud.io")
-      config.read_or_create
-      client = Client.new(config)
-      print "Trying to find a repository at #{repo}... "
-      repo = client.repository(repo)
-      print "success!\n"
-      print "Pushing package #{package_file}... "
-      repo.create_package(package_file)
+  module CLI
+    autoload :Distro,      "package_cloud/cli/distro"
+    autoload :Entry,       "package_cloud/cli/entry"
+    autoload :MasterToken, "package_cloud/cli/master_token"
+    autoload :ReadToken,   "package_cloud/cli/read_token"
+    autoload :Repository,  "package_cloud/cli/repository"
+    autoload :GpgKey,      "package_cloud/cli/gpg_key"
+
+    class Base < Thor
+      class_option "config", :desc => "Specify a path to config file containing your API token and URL; default is ~/.packagecloud"
+      class_option "url", :desc => "Specify the website URL to use; default is https://packagecloud.io. Useful for packagecloud:enterprise users."
+      class_option "verbose", :type => :boolean, :desc => "Enable verbose mode."
+
+      private
+        def get_valid(prompt)
+          selection = ""
+          times = 0
+          until yield(selection)
+            if times > 0
+              puts "#{selection} is not a valid selection."
+            end
+            print "#{prompt}: "
+            selection = ::Kernel.gets.chomp
+            times += 1
+          end
+
+          selection
+        end
+
+        def config
+          $logger = ::Logger.new(STDOUT)
+          $verbose = !!options[:verbose]
+          if $verbose
+            $logger.level = ::Logger::DEBUG
+            $logger.debug("verbose mode enabled")
+          else
+            $logger.level = ::Logger::WARN
+          end
+          @config ||= begin
+            ConfigFile.new(options[:config] || "~/.packagecloud",
+                         options[:url] || "https://packagecloud.io").tap(&:read_or_create)
+                      end
+        end
+
+        def client
+          @client ||= Client.new(config)
+        end
     end
   end
 end

data/lib/package_cloud/client.rb

@@ -7,14 +7,55 @@ module PackageCloud
       @config = config
     end
 
+    def repositories
+      url = PackageCloud::Util.compute_url(@config.base_url, "/api/v1/repos.json")
+      begin
+        attrs = JSON.parse(RestClient.get(url))
+        attrs.map { |a| Repository.new(a, @config) }
+      rescue RestClient::ResourceNotFound => e
+        print "failed!\n".color(:red)
+        exit(127)
+      end
+    end
+
     def repository(name)
-      base_url = @config.base_url
       user, repo = name.split("/")
+      url = PackageCloud::Util.compute_url(@config.base_url, "/api/v1/repos/#{user}/#{repo}.json")
       begin
-        attrs = JSON.parse(RestClient.get("#{base_url}/#{user}/#{repo}.json"))
+        attrs = JSON.parse(RestClient.get(url))
+        if attrs["error"] == "not_found"
+          print "failed... Repository #{user}/#{repo} not found!\n".color(:red)
+          exit(127)
+        end
+
         Repository.new(attrs, @config)
       rescue RestClient::ResourceNotFound => e
-        print "failed!\n".red
+        print "failed!\n".color(:red)
+        exit(127)
+      end
+    end
+
+    def create_repo(name, priv)
+      url = PackageCloud::Util.compute_url(@config.base_url, "/api/v1/repos.json")
+      begin
+        JSON.parse(RestClient.post(url, :repository => {:name => name, :private => priv == "private" ? "1" : "0"}))
+      rescue RestClient::UnprocessableEntity => e
+        print "error!\n".color(:red)
+        json = JSON.parse(e.response)
+        json.each do |k,v|
+          puts "\n\t#{k}: #{v.join(", ")}\n"
+        end
+        puts ""
+        exit(1)
+      end
+    end
+
+    def distributions
+      url = PackageCloud::Util.compute_url(@config.base_url, "/api/v1/distributions.json")
+      begin
+        JSON.parse(RestClient.get(url))
+      rescue RestClient::ResourceNotFound => e
+        print "failed!\n".color(:red)
         exit(127)
       end
     end

data/lib/package_cloud/config_file.rb

@@ -1,54 +1,109 @@
 require "highline/import"
 require "json"
+require "uri"
+require "cgi"
 
 module PackageCloud
   class ConfigFile
     attr_reader :token
 
-    def initialize(filename = "~/.packagecloud", url = "packagecloud.io")
+    def initialize(filename = "~/.packagecloud", url = "https://packagecloud.io")
+      handle_locale
       @filename = File.expand_path(filename)
-      @url = url
+      @url = URI(url)
     end
 
     def read_or_create
-      if File.exist?(@filename)
+      if ENV["PACKAGECLOUD_TOKEN"]
+        if ENV["PACKAGECLOUD_TOKEN"].length < 48
+          puts "Found PACKAGECLOUD_TOKEN environment variable but is empty or too short! Visit https://packagecloud.io/api_token and confirm it is correct."
+          exit!
+        end
+        @token = ENV["PACKAGECLOUD_TOKEN"]
+        @url   = URI(ENV["PACKAGECLOUD_URL"]) if ENV["PACKAGECLOUD_URL"]
+        output_host_and_token
+      elsif File.exist?(@filename)
         attrs = JSON.parse(File.read(@filename))
         @token = attrs["token"] if attrs.has_key?("token")
-        @url   = attrs["url"] if attrs.has_key?("url")
+        @url   = URI(attrs["url"]) if attrs.has_key?("url")
+        fix_config_file!
+        output_host_and_token
       else
         puts "No config file exists at #{@filename}. Login to create one."
 
         @token = login_from_console
+        print "Got your token. Writing a config file to #{@filename}... "
         write
+        puts "success!"
       end
     end
 
     def url
-      @url ||= "packagecloud.io"
+      @url ||= URI("https://packagecloud.io")
     end
 
     def base_url(username = token, password = "")
-      "https://#{CGI.escape(username)}:#{CGI.escape(password)}@#{url}"
+      u = url.dup
+      u.user = CGI.escape(username)
+      u.password = CGI.escape(password)
+      u.to_s
     end
 
     private
+      def handle_locale
+        # Force the external encoding to be UTF-8 on windows and everywhere
+        # else. This will somtimes fail on windows because it seems the default
+        # windows encoding on windows is IBM 437 and it
+        # is very painful to change to UTF-8. The failure in this case will
+        # just be 1 "?" being printed per character that isn't
+        # representable.
+        Encoding.default_external = 'UTF-8'
+      end
+
       def login_from_console
         e     = ask("Email:")
+        puts "If you signed up via social login (Github, Bitbucket etc.), and/or do not have a password, input: NIL"
         p     = ask("Password:") { |q| q.echo = false }
 
-        begin
-          PackageCloud::Auth.get_token(base_url(e, p))
-        rescue RestClient::Unauthorized => e
-          puts "Sorry, but we couldn't find you. Give it another try."
-          login_from_console
+        if p == "NIL"
+          puts "Copy your API Token from https://packagecloud.io/api_token and input below."
+          puts "(Note: An incorrectly inputted token will require deletion of the incorrectly generated $HOME/.packagecloud config file before rerunning the last command.)"
+          api_token = ask("Your API Token:") { |q| q.echo = false }
+        else
+          begin
+            api_token = PackageCloud::Auth.get_token(base_url(e, p))
+          rescue RestClient::Unauthorized => e
+            puts "Sorry, but we couldn't find you. Give it another try."
+            puts "(Or skip the login? Go to https://packagecloud.io/api_token to see instructions on downloading your $HOME/.packagecloud config file.)"
+            login_from_console
+          end
         end
+
+        return api_token
       end
 
       def write
-        print "Got your token. Writing a config file to #{@filename}... "
-        attrs = {url: @url, token: @token}
+        attrs = {:url => url.to_s, :token => @token}
         File.open(@filename, "w", 0600) { |f| f << JSON.dump(attrs); f << "\r\n" }
-        puts "success!"
       end
+
+      def output_host_and_token
+        token = @token[-4..-1].rjust(10, '*')
+        puts "Using #{@url} with token:#{token}"
+      end
+
+      ## package_cloud versions prior to 0.2.17 have a bug in the
+      ## config where the url is used verbatim as the key, instead of "url",
+      ## this attempts to fix the config file
+      def fix_config_file!
+        if File.exist?(@filename) && File.writable?(@filename)
+          attrs = JSON.parse(File.read(@filename))
+          if !attrs.has_key?("url")
+            ## overwrite the config file if "url" key not found
+            write
+          end
+        end
+      end
+
   end
 end

data/lib/package_cloud/gpg_key.rb

@@ -0,0 +1,13 @@
+module PackageCloud
+  class GpgKey < Object
+    def initialize(attrs, config)
+      @attrs = attrs
+      @config = config
+    end
+
+    def destroy
+      url = PackageCloud::Util.compute_url(@config.base_url, @attrs["self"])
+      RestClient.delete(url)
+    end
+  end
+end

data/lib/package_cloud/master_token.rb

@@ -0,0 +1,19 @@
+module PackageCloud
+  class MasterToken < Object
+    def initialize(attrs, config)
+      @attrs = attrs
+      @config = config
+    end
+
+    def read_tokens
+      @attrs["read_tokens"].map do |read_token|
+        ReadToken.new(@config, read_token)
+      end
+    end
+
+    def destroy
+      url = PackageCloud::Util.compute_url(@config.base_url, paths["self"])
+      RestClient.delete(url)
+    end
+  end
+end

data/lib/package_cloud/read_token.rb

@@ -0,0 +1,14 @@
+module PackageCloud
+  class ReadToken < Object
+    def initialize(config, attrs)
+      @config = config
+      @attrs = attrs
+    end
+
+    def destroy(master_token_path, read_token_id)
+      base_url = @config.base_url
+      url = "#{base_url}#{master_token_path}/read_tokens/#{read_token_id}"
+      RestClient.delete(url)
+    end
+  end
+end

data/lib/package_cloud/repository.rb

@@ -1,3 +1,5 @@
+require 'tempfile'
+
 module PackageCloud
   class Repository < Object
     def initialize(attrs, config)
@@ -5,15 +7,150 @@ module PackageCloud
       @config = config
     end
 
-    def create_package(file_path)
+    def parse_dsc(dsc_path, dist_id)
+      file_data = File.new(dsc_path, 'rb')
+      base_url = @config.base_url
+      url = PackageCloud::Util.compute_url(base_url, paths["package_contents"])
+      begin
+        resp = RestClient::Request.execute(:method => 'post',
+                                           :url => url,
+                                           :timeout => nil,
+                                           :payload => { :package => {:package_file      => file_data,
+                                                                      :distro_version_id => dist_id}})
+        resp = JSON.parse(resp)
+        print "success!\n"
+        resp["files"]
+      rescue RestClient::UnprocessableEntity => e
+        print "error:\n".color(:red)
+        json = JSON.parse(e.response)
+        json.each do |k,v|
+          puts "\n\t#{k}: #{v.join(", ")}\n"
+        end
+        puts ""
+        exit(1)
+      end
+    end
+
+    def create_upload
+      base_url = @config.base_url
+      url = PackageCloud::Util.compute_url(base_url, paths["create_upload"])
+      begin
+        JSON.parse(RestClient.post(url, {}))
+      rescue RestClient::UnprocessableEntity => e
+        print "error!\n".color(:red)
+        json = JSON.parse(e.response)
+        json.each do |k,v|
+          puts "\n\t#{k}: #{v.join(", ")}\n"
+        end
+        puts
+        exit(1)
+      rescue RestClient::ResourceNotFound => e
+        print "failed!\n".color(:red)
+        exit(127)
+      end
+    end
+
+    def create_package(file_path, file_url, dist_id, files=nil, urls=nil, filetype=nil, coordinates=nil)
+      base_url = @config.base_url
+      url = PackageCloud::Util.compute_url(base_url, paths["create_package"])
+      params = {
+        :distro_version_id => dist_id,
+      }
+
+      if file_url
+        params[:url] = file_url
+      else
+        params[:package_file] = File.new(file_path, 'rb')
+      end
+
+      if coordinates
+        params[:coordinates] = coordinates
+      end
+
+      if filetype == "dsc"
+        if urls
+          params[:source_urls] = urls
+        else
+          params[:source_files] = files.map do |f|
+            File.new(f, 'rb')
+          end
+        end
+      end
+
+      RestClient::Request.execute(
+        :method => 'post',
+        :url => url,
+        :timeout => nil,
+        :payload => { :package =>  params },
+      )
+
+      print "success!\n".color(:green)
+    end
+
+    def install_script(type)
+      url = urls["install_script"].gsub(/:package_type/, type)
+
+      # the URL we've obtained above already contains the correct tokens
+      # because the install script URL uses a master token for access, not
+      # your API token, so if we pass @config.base_url in to compute_url,
+      # we'll end up generating a URL like: https://token:@https://token:@...
+      # because @config.base_url has the url with the API token in it and url
+      # has the url (lol) with the master token in it.
+      #
+      # so just pass url in here.
+      url = PackageCloud::Util.compute_url(url, '')
+      script = RestClient.get(url)
+
+      # persist the script to a tempfile to make it easier to execute
+      file = Tempfile.new('foo')
+      file.write(script)
+      file.close
+      file
+    end
+
+    def create_gpg_key(file_path)
       file_data = File.new(file_path, 'rb')
-      base_url = @config.base_url 
-      url = base_url + paths["create_package"]
+      base_url = @config.base_url
+      url = PackageCloud::Util.compute_url(@config.base_url, paths["gpg_keys"])
+      params = { keydata: file_data }
+
+      print "Attempting to upload key file #{file_path}... "
+
       begin
-        RestClient.post(url, package: {package_file: file_data})
-        print "success!\n".green
+        RestClient::Request.execute(:method => 'post',
+                                    :url => url,
+                                    :timeout => nil,
+                                    :payload => { :gpg_key => params })
       rescue RestClient::UnprocessableEntity => e
-        print "error:\n".red
+        print "error: ".color(:red)
+        json = JSON.parse(e.response)
+        puts json["error"]
+        puts ""
+        exit(1)
+      end
+
+      print "success!\n".color(:green)
+    end
+
+    def gpg_keys
+      url = PackageCloud::Util.compute_url(@config.base_url, paths["gpg_keys"])
+      attrs = JSON.parse(RestClient.get(url))
+      attrs["gpg_keys"].map { |a| GpgKey.new(a, @config) }
+    end
+
+    def master_tokens
+      url = PackageCloud::Util.compute_url(@config.base_url, paths["master_tokens"])
+      attrs = JSON.parse(RestClient.get(url))
+      attrs.map { |a| MasterToken.new(a, @config) }
+    end
+
+    def create_master_token(name)
+      url = PackageCloud::Util.compute_url(@config.base_url, paths["create_master_token"])
+      begin
+        resp = RestClient.post(url, :master_token => {:name => name})
+        resp = JSON.parse(resp)
+      rescue RestClient::UnprocessableEntity => e
+        print "error:\n".color(:red)
         json = JSON.parse(e.response)
         json.each do |k,v|
           puts "\n\t#{k}: #{v.join(", ")}\n"
@@ -21,6 +158,50 @@ module PackageCloud
         puts ""
         exit(1)
       end
+      resp
+    end
+
+    def promote(dist, package_name, dest_repo_name, scope=nil)
+      begin
+        url = PackageCloud::Util.compute_url(@config.base_url, paths["self"] + "/" + [dist, package_name, "promote.json"].compact.join("/"))
+        resp = if scope
+                 RestClient.post(url, destination: dest_repo_name, scope: scope)
+               else
+                 RestClient.post(url, destination: dest_repo_name)
+               end
+        resp = JSON.parse(resp)
+      rescue RestClient::UnprocessableEntity, RestClient::ResourceNotFound => e
+        print "error:\n".color(:red)
+        json = JSON.parse(e.response)
+        json.each do |k,v|
+          puts "\n\t#{k}: #{v.join(", ")}\n"
+        end
+        puts ""
+        exit(1)
+      end
+    end
+
+    def yank(dist, package_name, scope=nil)
+      begin
+        url = PackageCloud::Util.compute_url(@config.base_url, paths["self"] + "/" + [dist, package_name].compact.join("/"))
+        if scope
+          RestClient.delete(url, params: { scope: scope })
+        else
+          RestClient.delete(url)
+        end
+      rescue RestClient::ResourceNotFound => e
+        print "error:\n".color(:red)
+        json = JSON.parse(e.response)
+        json.each do |k,v|
+          puts "\n\t#{k}: #{v.join(", ")}\n"
+        end
+        puts ""
+        exit(1)
+      end
+    end
+
+    def private_human
+      send(:private) ? "private".color(:red) : "public".color(:green)
     end
   end
 end

data/lib/package_cloud/util.rb

@@ -0,0 +1,17 @@
+require 'open-uri'
+
+module PackageCloud
+  class Util
+    class << self
+      def compute_url(base_url, path)
+        url = base_url + path
+        proxy_uri = URI.parse(url).find_proxy()
+        if proxy_uri
+          RestClient.proxy = proxy_uri.to_s
+        end
+
+        url
+      end
+    end
+  end
+end

data/lib/package_cloud/validator.rb

@@ -0,0 +1,118 @@
+module PackageCloud
+  class Validator
+    def initialize(client)
+      @client = client
+    end
+
+    def distribution_id_from_repo_url(repo, filenames)
+      _,_,dist_sel,ver_sel = repo.split("/")
+     package_type = dist_sel
+     puts "ambiguous extensions, so using repo url to deduce package_type, package_type: #{package_type}".color(:red)
+
+     # NOTE: The distributions pulled from API uses "py" (package_type) as key for "python"
+     #       so we need to map "python" to "py"
+     #       See PackageCloud::Validator#distributions
+     package_type = package_type == "python" ? "py": package_type
+
+     distribution_id(repo, filenames, package_type)
+    end
+
+    def distribution_id(repo, filenames, package_type)
+      if distributions[package_type]
+        _,_,dist_sel,ver_sel = repo.split("/")
+
+        # These are all 'single version' distros
+        if (dist_sel == "python" || dist_sel == "java" || dist_sel == "node" || dist_sel == "anyfile")
+          dist = distributions[package_type].detect { |d| d["index_name"] == dist_sel }
+          dist["versions"].first["id"]
+        elsif dist_sel && ver_sel
+          dist = distributions[package_type].detect { |d| d["index_name"] == dist_sel }
+
+          if dist
+            ver = dist["versions"].detect { |v| v["index_name"] == ver_sel || v["version_number"] == ver_sel }
+
+            if ver
+              ver["id"]
+            else
+              puts "#{ver_sel} isn't a valid version of #{dist["display_name"]}\n\n"
+              select_dist(repo, filenames, package_type)
+            end
+          else
+            puts "#{dist_sel} isn't a valid operating system.\n\n"
+            select_dist(repo, filenames, package_type)
+          end
+        else
+          puts "#{package_type} packages require an operating system and version to be selected.\n\n"
+          select_dist(repo, filenames, package_type)
+        end
+      else
+        nil
+      end
+    end
+
+    private
+      def distributions
+        @distributions ||= @client.distributions
+      end
+
+      def select_from(list)
+        selection = get_valid("0-#{list.length - 1}") do |s|
+          s =~ /^\d+$/ && list[s.to_i]
+        end
+
+        list[selection.to_i]
+      end
+
+      def get_valid(prompt)
+        selection = ""
+        times = 0
+        until yield(selection)
+          if times > 0
+            puts "#{selection} is not a valid selection."
+          end
+          print "\n #{prompt}: "
+          selection = ::Kernel.gets.chomp
+          times += 1
+        end
+
+        selection
+      end
+
+      def select_dist(repo, filenames, package_type)
+        puts "If you don't see your OS or version here, send us an email at support@packagecloud.io:\n\n"
+        all_distros = distributions[package_type]
+
+        filtered_distros = all_distros.select {|dist| dist["index_name"] != "any" && dist["index_name"] != "rpm_any" }
+        
+        filtered_distros.each_with_index do |dist, index|
+          puts "\t#{index}. #{dist["display_name"]}"
+        end
+
+        distro = select_from(filtered_distros)
+
+        puts "\nYou selected #{distro["display_name"]}. Select a version:\n\n"
+        distro["versions"].each_with_index do |ver, index|
+          puts "\t#{index}. #{ver["display_name"]} (#{ver["index_name"]})"
+        end
+        version = select_from(distro["versions"])
+
+        repo = repo.split("/")[0..1].join("/")
+        os_shortcut = "#{distro["index_name"]}/#{version["index_name"]}"
+        shortcut = "#{repo}/#{os_shortcut}"
+        if filenames.length > 1
+          puts "\nPush #{filenames.length} packages to #{shortcut}? "
+        else
+          puts "\nPush #{filenames.first} to #{shortcut}? "
+        end
+        answer = get_valid("(y/n)") { |sel| sel == "y" || sel == "n" }
+
+        if answer == "y"
+          print "\nContinuing...".color(:green)
+          puts " Note that next time you can push directly to #{os_shortcut} by specifying #{shortcut} on the commandline."
+          version["id"]
+        else
+          abort("Cancelled.")
+        end
+      end
+  end
+end

data/lib/package_cloud/version.rb

@@ -1,3 +1,7 @@
 module PackageCloud
-  VERSION = "0.0.3"
+  MAJOR_VERSION = "0"
+  MINOR_VERSION = "3"
+  PATCH_VERSION = "15"
+
+  VERSION = [MAJOR_VERSION, MINOR_VERSION, PATCH_VERSION].join(".")
 end

data/lib/package_cloud.rb

@@ -1,11 +1,17 @@
 require "package_cloud/version"
 require "cgi"
+require 'rainbow/ext/string'
 
 module PackageCloud
   autoload :Auth, "package_cloud/auth"
   autoload :CLI, "package_cloud/cli"
   autoload :Client, "package_cloud/client"
   autoload :ConfigFile, "package_cloud/config_file"
+  autoload :MasterToken, "package_cloud/master_token"
   autoload :Object, "package_cloud/object"
+  autoload :ReadToken, "package_cloud/read_token"
   autoload :Repository, "package_cloud/repository"
+  autoload :Validator, "package_cloud/validator"
+  autoload :Util, "package_cloud/util"
+  autoload :GpgKey, "package_cloud/gpg_key"
 end