Class: PackageCloud::Repository

Inherits:
Object
  • Object
show all
Defined in:
lib/package_cloud/repository.rb

Instance Method Summary collapse

Methods inherited from Object

#method_missing, #respond_to?

Constructor Details

#initialize(attrs, config) ⇒ Repository

Returns a new instance of Repository.



5
6
7
8
 
# File 'lib/package_cloud/repository.rb', line 5

def initialize(attrs, config)
  @attrs = attrs
  @config = config
end

Dynamic Method Handling

This class handles dynamic methods through the method_missing method in the class PackageCloud::Object

Instance Method Details

#create_master_token(name) ⇒ Object 



86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
 
# File 'lib/package_cloud/repository.rb', line 86

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"
    end
    puts ""
    exit(1)
  end
  resp
end

#create_package(file_path, dist_id, files = nil, filetype = nil, coordinates = nil) ⇒ Object 



34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
 
# File 'lib/package_cloud/repository.rb', line 34

def create_package(file_path, dist_id, files=nil, filetype=nil, coordinates=nil)
  file_data = File.new(file_path, 'rb')
  base_url = @config.base_url
  url = PackageCloud::Util.compute_url(base_url, paths["create_package"])
  params = { :package_file => file_data,
             :distro_version_id => dist_id }

 if coordinates
   params.merge!(:coordinates => coordinates)
 end

  if filetype == "dsc"
    file_ios = files.inject([]) do |memo, f|
      memo << File.new(f, 'rb')
    end
    params.merge!({:source_files => file_ios})
  end

  RestClient::Request.execute(:method => 'post',
                              :url => url,
                              :timeout => -1,
                              :payload => { :package =>  params })
  print "success!\n".color(:green)
end

#install_script(type) ⇒ Object 



59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
 
# File 'lib/package_cloud/repository.rb', line 59

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

#master_tokens ⇒ Object 



80
81
82
83
84
 
# File 'lib/package_cloud/repository.rb', line 80

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

#parse_dsc(dsc_path, dist_id) ⇒ Object 



10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
 
# File 'lib/package_cloud/repository.rb', line 10

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 => -1,
                                       :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

#private_human ⇒ Object 



134
135
136
 
# File 'lib/package_cloud/repository.rb', line 134

def private_human
  send(:private) ? "private".color(:red) : "public".color(:green)
end

#promote(dist, package_name, dest_repo_name) ⇒ Object 



103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
 
# File 'lib/package_cloud/repository.rb', line 103

def promote(dist, package_name, dest_repo_name)
  begin
    url = PackageCloud::Util.compute_url(@config.base_url, paths["self"] + "/" + [dist, package_name, "promote.json"].compact.join("/"))
    resp = RestClient.post(url, :destination => dest_repo_name)
    resp = JSON.parse(resp)
  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

#yank(dist, package_name) ⇒ Object 



119
120
121
122
123
124
125
126
127
128
129
130
131
132
 
# File 'lib/package_cloud/repository.rb', line 119

def yank(dist, package_name)
  begin
    url = PackageCloud::Util.compute_url(@config.base_url, paths["self"] + "/" + [dist, package_name].compact.join("/"))
    RestClient.delete(url)
  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