dockerapi 0.5.0 → 0.9.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
data/bin/setup CHANGED
@@ -1,8 +1,22 @@
1
1
  #!/usr/bin/env bash
2
2
  set -euo pipefail
3
3
  IFS=$'\n\t'
4
- set -vx
5
-
6
- bundle install
4
+ #set -vx
7
5
 
8
6
  # Do any other automated setup that you need to do here
7
+ if [ $USER == 'root' ]
8
+ then
9
+ echo "Enabling TCP port 2375 for external connection to Docker"
10
+ echo '{"hosts": ["tcp://0.0.0.0:2375", "unix:///var/run/docker.sock"]}' > /etc/docker/daemon.json
11
+ mkdir -p /etc/systemd/system/docker.service.d
12
+ echo '[Service]' > /etc/systemd/system/docker.service.d/override.conf
13
+ echo 'ExecStart=' >> /etc/systemd/system/docker.service.d/override.conf
14
+ echo 'ExecStart=/usr/bin/dockerd' >> /etc/systemd/system/docker.service.d/override.conf
15
+ systemctl daemon-reload
16
+ systemctl restart docker.service
17
+ echo "Done!"
18
+ else
19
+ echo "Running bundle install"
20
+ bundle install
21
+ echo "Run this script as root for further configurations"
22
+ fi
@@ -1,18 +1,20 @@
1
1
  module Docker
2
2
  module API
3
3
  class Base
4
+
5
+ def initialize connection = nil
6
+ raise Docker::API::Error.new("Expect connection to be a Docker::API::Connection class") if connection != nil && !connection.is_a?(Docker::API::Connection)
7
+ @connection = connection || Docker::API::Connection.new
8
+ end
4
9
 
5
10
  private
6
11
 
7
- def self.base_path
12
+ def base_path # TODO: this method to be removed?
8
13
  "/"
9
14
  end
10
15
 
11
- def self.connection
12
- Docker::API::Connection.instance
13
- end
14
-
15
- def self.validate error, permitted, params
16
+ def validate error, permitted, params
17
+ return if params[:skip_validation]
16
18
  unpermitted = params.keys.map(&:to_s) - permitted.map(&:to_s)
17
19
  raise error.new(permitted, unpermitted) if unpermitted.size > 0
18
20
  end
@@ -20,14 +22,14 @@ module Docker
20
22
  ## Converts Ruby Hash into query parameters
21
23
  ## In general, the format is key=value
22
24
  ## If value is another Hash, it should keep a json syntax {key:value}
23
- def self.hash_to_params h
25
+ def hash_to_params h
24
26
  p = []
25
- h.each { |k,v| p.push( v.is_a?(Hash) ? "#{k}=#{v.to_json}" : "#{k}=#{v}") }
27
+ h.delete_if{ | k, v | k.to_s == "skip_validation" }.each { |k,v| p.push( v.is_a?(Hash) ? "#{k}=#{v.to_json}" : "#{k}=#{v}") }
26
28
  p.join("&").gsub(" ","")
27
29
  end
28
30
 
29
- def self.build_path path, params = {}
30
- p = path.is_a?(Array) ? ([base_path] << path).join("/") : path
31
+ def build_path path, params = {}
32
+ p = path.is_a?(Array) ? ([base_path] << path).join("/") : path # TODO: this line to be removed?
31
33
  params.size > 0 ? [p, hash_to_params(params)].join("?") : p
32
34
  end
33
35
 
@@ -1,24 +1,18 @@
1
- require "singleton"
2
1
  module Docker
3
2
  module API
4
3
  class Connection
5
- include Singleton
6
-
7
4
  [:get, :post, :head, :delete, :put].each do | method |
8
5
  define_method(method) { | path | self.request(method: method, path: path) }
9
6
  end
10
7
 
11
- def post(path, body = nil)
12
- self.request(method: :post, path: path, headers: { "Content-Type" => "application/json" }, body: body.to_json)
13
- end
14
-
15
8
  def request params
16
9
  Docker::API::Response.new(@connection.request(params).data)
17
10
  end
18
11
 
19
- private
20
- def initialize
21
- @connection = Excon.new('unix:///', :socket => '/var/run/docker.sock')
12
+ def initialize url = nil, params = nil
13
+ url ||= 'unix:///'
14
+ params ||= url == 'unix:///' ? {socket: '/var/run/docker.sock'} : {}
15
+ @connection = Excon.new(url, params)
22
16
  end
23
17
 
24
18
  end
@@ -5,111 +5,107 @@ module Docker
5
5
 
6
6
  class Container < Docker::API::Base
7
7
 
8
- def self.base_path
9
- "/containers"
10
- end
11
-
12
- def self.list params = {}
8
+ def list params = {}
13
9
  validate Docker::API::InvalidParameter, [:all, :limit, :size, :filters], params
14
- connection.get(build_path(["json"], params))
10
+ @connection.get(build_path(["json"], params))
15
11
  end
16
12
 
17
- def self.inspect name, params = {}
13
+ def details name, params = {}
18
14
  validate Docker::API::InvalidParameter, [:size], params
19
- connection.get(build_path([name, "json"], params))
15
+ @connection.get(build_path([name, "json"], params))
20
16
  end
21
17
 
22
- def self.top name, params = {}
18
+ def top name, params = {}
23
19
  validate Docker::API::InvalidParameter, [:ps_args], params
24
- connection.get(build_path([name, "top"], params))
20
+ @connection.get(build_path([name, "top"], params))
25
21
  end
26
22
 
27
- def self.changes name
28
- connection.get(build_path([name, "changes"]))
23
+ def changes name
24
+ @connection.get(build_path([name, "changes"]))
29
25
  end
30
26
 
31
- def self.start name, params = {}
27
+ def start name, params = {}
32
28
  validate Docker::API::InvalidParameter, [:detachKeys], params
33
- connection.post(build_path([name, "start"], params))
29
+ @connection.post(build_path([name, "start"], params))
34
30
  end
35
31
 
36
- def self.stop name, params = {}
32
+ def stop name, params = {}
37
33
  validate Docker::API::InvalidParameter, [:t], params
38
- connection.post(build_path([name, "stop"], params))
34
+ @connection.post(build_path([name, "stop"], params))
39
35
  end
40
36
 
41
- def self.restart name, params = {}
37
+ def restart name, params = {}
42
38
  validate Docker::API::InvalidParameter, [:t], params
43
- connection.post(build_path([name, "restart"], params))
39
+ @connection.post(build_path([name, "restart"], params))
44
40
  end
45
41
 
46
- def self.kill name, params = {}
42
+ def kill name, params = {}
47
43
  validate Docker::API::InvalidParameter, [:signal], params
48
- connection.post(build_path([name, "kill"], params))
44
+ @connection.post(build_path([name, "kill"], params))
49
45
  end
50
46
 
51
- def self.wait name, params = {}
47
+ def wait name, params = {}
52
48
  validate Docker::API::InvalidParameter, [:condition], params
53
- connection.post(build_path([name, "wait"], params))
49
+ @connection.post(build_path([name, "wait"], params))
54
50
  end
55
51
 
56
- def self.update name, body = {}
52
+ def update name, body = {}
57
53
  validate Docker::API::InvalidRequestBody, Docker::API::UpdateBody, body
58
- connection.post(build_path([name, "update"]), body)
54
+ @connection.request(method: :post, path: build_path([name, "update"]), headers: {"Content-Type": "application/json"}, body: body.to_json)
59
55
  end
60
56
 
61
- def self.rename name, params = {}
57
+ def rename name, params = {}
62
58
  validate Docker::API::InvalidParameter, [:name], params
63
- connection.post(build_path([name, "rename"], params))
59
+ @connection.post(build_path([name, "rename"], params))
64
60
  end
65
61
 
66
- def self.resize name, params = {}
62
+ def resize name, params = {}
67
63
  validate Docker::API::InvalidParameter, [:w, :h], params
68
- connection.post(build_path([name, "resize"], params))
64
+ @connection.post(build_path([name, "resize"], params))
69
65
  end
70
66
 
71
- def self.prune params = {}
67
+ def prune params = {}
72
68
  validate Docker::API::InvalidParameter, [:filters], params
73
- connection.post(build_path(["prune"], params))
69
+ @connection.post(build_path(["prune"], params))
74
70
  end
75
71
 
76
- def self.pause name
77
- connection.post(build_path([name, "pause"]))
72
+ def pause name
73
+ @connection.post(build_path([name, "pause"]))
78
74
  end
79
75
 
80
- def self.unpause name
81
- connection.post(build_path([name, "unpause"]))
76
+ def unpause name
77
+ @connection.post(build_path([name, "unpause"]))
82
78
  end
83
79
 
84
- def self.remove name, params = {}
80
+ def remove name, params = {}
85
81
  validate Docker::API::InvalidParameter, [:v, :force, :link], params
86
- connection.delete(build_path([name]))
82
+ @connection.delete(build_path([name]))
87
83
  end
88
84
 
89
- def self.logs name, params = {}
85
+ def logs name, params = {}
90
86
  validate Docker::API::InvalidParameter, [:follow, :stdout, :stderr, :since, :until, :timestamps, :tail], params
91
87
 
92
88
  path = build_path([name, "logs"], params)
93
89
 
94
90
  if params[:follow] == true || params[:follow] == 1
95
- connection.request(method: :get, path: path , response_block: lambda { |chunk, remaining_bytes, total_bytes| puts chunk.inspect })
91
+ @connection.request(method: :get, path: path , response_block: lambda { |chunk, remaining_bytes, total_bytes| puts chunk.inspect })
96
92
  else
97
- connection.get(path)
93
+ @connection.get(path)
98
94
  end
99
95
  end
100
96
 
101
- def self.attach name, params = {}
97
+ def attach name, params = {}
102
98
  validate Docker::API::InvalidParameter, [:detachKeys, :logs, :stream, :stdin, :stdout, :stderr], params
103
- connection.request(method: :post, path: build_path([name, "attach"], params) , response_block: lambda { |chunk, remaining_bytes, total_bytes| puts chunk.inspect })
99
+ @connection.request(method: :post, path: build_path([name, "attach"], params) , response_block: lambda { |chunk, remaining_bytes, total_bytes| puts chunk.inspect })
104
100
  end
105
101
 
106
- def self.create params = {}, body = {}
102
+ def create params = {}, body = {}
107
103
  validate Docker::API::InvalidParameter, [:name], params
108
104
  validate Docker::API::InvalidRequestBody, Docker::API::CreateBody, body
109
- connection.post(build_path(["create"], params), body)
105
+ @connection.request(method: :post, path: build_path(["create"], params), headers: {"Content-Type": "application/json"}, body: body.to_json)
110
106
  end
111
107
 
112
- def self.stats name, params = {}
108
+ def stats name, params = {}
113
109
  validate Docker::API::InvalidParameter, [:stream], params
114
110
  path = build_path([name, "stats"], params)
115
111
 
@@ -117,43 +113,58 @@ module Docker
117
113
  streamer = lambda do |chunk, remaining_bytes, total_bytes|
118
114
  puts chunk
119
115
  end
120
- connection.request(method: :get, path: path , response_block: streamer)
116
+ @connection.request(method: :get, path: path , response_block: streamer)
121
117
  else
122
- connection.get(path)
118
+ @connection.get(path)
123
119
  end
124
120
  end
125
121
 
126
- def self.export name, path = "exported_container"
127
- response = Docker::API::Container.inspect(name)
122
+ def export name, path = "exported_container"
123
+ response = self.details(name)
128
124
  if response.status == 200
129
125
  file = File.open(File.expand_path(path), "wb")
130
126
  streamer = lambda do |chunk, remaining_bytes, total_bytes|
131
127
  file.write(chunk)
132
128
  end
133
- response = connection.request(method: :get, path: build_path([name, "export"]) , response_block: streamer)
129
+ response = @connection.request(method: :get, path: build_path([name, "export"]) , response_block: streamer)
134
130
  file.close
135
131
  end
136
132
  response
137
133
  end
138
134
 
139
- def self.archive name, file, params = {}
135
+ def archive name, file, params = {}
140
136
  validate Docker::API::InvalidParameter, [:path, :noOverwriteDirNonDir, :copyUIDGID], params
141
137
 
142
138
  begin # File exists on disk, send it to container
143
139
  file = File.open( File.expand_path( file ) , "r")
144
- response = connection.request(method: :put, path: build_path([name, "archive"], params) , request_block: lambda { file.read(Excon.defaults[:chunk_size]).to_s} )
140
+ response = @connection.request(method: :put, path: build_path([name, "archive"], params) , request_block: lambda { file.read(Excon.defaults[:chunk_size]).to_s} )
145
141
  file.close
146
142
  rescue Errno::ENOENT # File doesnt exist, get it from container
147
- response = connection.head(build_path([name, "archive"], params))
143
+ response = @connection.head(build_path([name, "archive"], params))
148
144
  if response.status == 200 # file exists in container
149
145
  file = File.open( File.expand_path( file ) , "wb")
150
- response = connection.request(method: :get, path: build_path([name, "archive"], params) , response_block: lambda { |chunk, remaining_bytes, total_bytes| file.write(chunk) })
146
+ response = @connection.request(method: :get, path: build_path([name, "archive"], params) , response_block: lambda { |chunk, remaining_bytes, total_bytes| file.write(chunk) })
151
147
  file.close
152
148
  end
153
149
  end
154
150
  response
155
151
  end
156
152
 
153
+ #################################################
154
+ # Items in this area to be removed before 1.0.0 #
155
+ #################################################
156
+ def base_path
157
+ "/containers"
158
+ end
159
+
160
+ def inspect *args
161
+ return super.inspect if args.size == 0
162
+ warn "WARNING: #inspect is deprecated and will be removed in the future, please use #details instead."
163
+ name, params = args[0], args[1] || {}
164
+ details(name, params)
165
+ end
166
+ #################################################
167
+
157
168
  end
158
169
  end
159
170
  end
@@ -0,0 +1,46 @@
1
+ module Docker
2
+ module API
3
+ class Exec < Docker::API::Base
4
+
5
+ def create name, body = {}
6
+ validate Docker::API::InvalidRequestBody, [:AttachStdin, :AttachStdout, :AttachStderr, :DetachKeys, :Tty, :Env, :Cmd, :Privileged, :User, :WorkingDir], body
7
+ @connection.request(method: :post, path: "/containers/#{name}/exec", headers: {"Content-Type": "application/json"}, body: body.to_json )
8
+ end
9
+
10
+ def start name, body = {}
11
+ validate Docker::API::InvalidRequestBody, [:Detach, :Tty], body
12
+
13
+ stream = ""
14
+ response = @connection.request(method: :post,
15
+ path: "/exec/#{name}/start",
16
+ headers: {"Content-Type": "application/json"},
17
+ body: body.to_json,
18
+ response_block: lambda { |chunk, remaining_bytes, total_bytes| stream += chunk.to_s.encode('UTF-8', invalid: :replace, undef: :replace, replace: '?') }
19
+ )
20
+ response.data.merge!({stream: stream})
21
+ response
22
+ end
23
+
24
+ def resize name, params = {}
25
+ validate Docker::API::InvalidParameter, [:w, :h], params
26
+ @connection.post(build_path("/exec/#{name}/resize", params))
27
+ end
28
+
29
+ def details name
30
+ @connection.get("/exec/#{name}/json")
31
+ end
32
+
33
+ #################################################
34
+ # Items in this area to be removed before 1.0.0 #
35
+ #################################################
36
+ def inspect *args
37
+ return super.inspect if args.size == 0
38
+ warn "WARNING: #inspect is deprecated and will be removed in the future, please use #details instead."
39
+ name = args[0]
40
+ details(name)
41
+ end
42
+ #################################################
43
+
44
+ end
45
+ end
46
+ end
@@ -7,113 +7,107 @@ module Docker
7
7
  BuildParams = [:dockerfile, :t, :extrahosts, :remote, :q, :nocache, :cachefrom, :pull, :rm, :forcerm, :memory, :memswap, :cpushares, :cpusetcpus, :cpuperiod, :cpuquota, :buildargs, :shmsize, :squash, :labels, :networkmode, :platform, :target, :outputs]
8
8
  class Image < Docker::API::Base
9
9
 
10
- def self.base_path
11
- "/images"
12
- end
13
-
14
- def self.inspect name
15
- connection.get(build_path([name, "json"]))
10
+ def details name
11
+ @connection.get(build_path([name, "json"]))
16
12
  end
17
13
 
18
- def self.history name
19
- connection.get(build_path([name, "history"]))
14
+ def history name
15
+ @connection.get(build_path([name, "history"]))
20
16
  end
21
17
 
22
- def self.list params = {}
18
+ def list params = {}
23
19
  validate Docker::API::InvalidParameter, [:all, :filters, :digests], params
24
- connection.get(build_path(["json"], params))
20
+ @connection.get(build_path(["json"], params))
25
21
  end
26
22
 
27
- def self.search params = {}
23
+ def search params = {}
28
24
  validate Docker::API::InvalidParameter, [:term, :limit, :filters], params
29
- connection.get(build_path(["search"], params))
25
+ @connection.get(build_path(["search"], params))
30
26
  end
31
27
 
32
- def self.tag name, params = {}
28
+ def tag name, params = {}
33
29
  validate Docker::API::InvalidParameter, [:repo, :tag], params
34
- connection.post(build_path([name, "tag"], params))
30
+ @connection.post(build_path([name, "tag"], params))
35
31
  end
36
32
 
37
- def self.prune params = {}
33
+ def prune params = {}
38
34
  validate Docker::API::InvalidParameter, [:filters], params
39
- connection.post(build_path(["prune"], params))
35
+ @connection.post(build_path(["prune"], params))
40
36
  end
41
37
 
42
- def self.remove name, params = {}
38
+ def remove name, params = {}
43
39
  validate Docker::API::InvalidParameter, [:force, :noprune], params
44
- connection.delete(build_path([name], params))
40
+ @connection.delete(build_path([name], params))
45
41
  end
46
42
 
47
- def self.export name, path = "exported_image"
43
+ def export name, path = "exported_image"
48
44
  file = File.open("/tmp/exported-image", "wb")
49
45
  streamer = lambda do |chunk, remaining_bytes, total_bytes|
50
46
  file.write(chunk)
51
47
  end
52
- response = connection.request(method: :get, path: build_path([name, "get"]) , response_block: streamer)
48
+ response = @connection.request(method: :get, path: build_path([name, "get"]) , response_block: streamer)
53
49
  file.close
54
50
  response.status == 200 ? FileUtils.mv("/tmp/exported-image", File.expand_path(path)) : FileUtils.rm("/tmp/exported-image")
55
51
  response
56
52
  end
57
53
 
58
- def self.import path, params = {}
54
+ def import path, params = {}
59
55
  validate Docker::API::InvalidParameter, [:quiet], params
60
56
  file = File.open(File.expand_path(path), "r")
61
- response = connection.request(method: :post, path: build_path(["load"], params) , headers: {"Content-Type" => "application/x-tar"}, request_block: lambda { file.read(Excon.defaults[:chunk_size]).to_s} )
57
+ response = @connection.request(method: :post, path: build_path(["load"], params) , headers: {"Content-Type" => "application/x-tar"}, request_block: lambda { file.read(Excon.defaults[:chunk_size]).to_s} )
62
58
  file.close
63
59
  response
64
60
  end
65
61
 
66
- def self.push name, params = {}, authentication = {}
62
+ def push name, params = {}, authentication = {}
67
63
  validate Docker::API::InvalidParameter, [:tag], params
68
64
 
69
65
  if authentication.keys.size > 0
70
- auth = Docker::API::System.auth(authentication)
71
- return auth unless [200, 204].include? auth.status
72
- connection.request(method: :post, path: build_path([name, "push"], params), headers: { "X-Registry-Auth" => Base64.encode64(authentication.to_json.to_s).chomp } )
66
+ @connection.request(method: :post, path: build_path([name, "push"], params), headers: { "X-Registry-Auth" => Base64.urlsafe_encode64(authentication.to_json.to_s).chomp } )
73
67
  else
74
- connection.post(build_path([name, "push"], params))
68
+ raise Docker::API::Error.new("Provide authentication parameters to push an image")
75
69
  end
76
70
  end
77
71
 
78
- def self.commit params = {}, body = {}
72
+ def commit params = {}, body = {}
79
73
  validate Docker::API::InvalidParameter, [:container, :repo, :tag, :comment, :author, :pause, :changes], params
80
74
  validate Docker::API::InvalidRequestBody, Docker::API::CommitBody, body
81
- container = Docker::API::Container.inspect(params[:container])
75
+ container = Docker::API::Container.new.details(params[:container])
82
76
  return container if [404, 301].include? container.status
83
77
  body = JSON.parse(container.body)["Config"].merge(body)
84
- connection.request(method: :post, path: build_path("/commit", params), headers: {"Content-Type": "application/json"}, body: body.to_json)
78
+ @connection.request(method: :post, path: build_path("/commit", params), headers: {"Content-Type": "application/json"}, body: body.to_json)
85
79
  end
86
80
 
87
- def self.create params = {}, authentication = {}
81
+ def create params = {}, authentication = {}
88
82
  validate Docker::API::InvalidParameter, [:fromImage, :fromSrc, :repo, :tag, :message, :platform], params
89
83
 
90
84
  if authentication.keys.size > 0
91
- auth = Docker::API::System.auth(authentication)
85
+ auth = Docker::API::System.new.auth(authentication)
92
86
  return auth unless [200, 204].include? auth.status
93
- connection.request(method: :post, path: build_path(["create"], params), headers: { "X-Registry-Auth" => Base64.encode64(authentication.to_json.to_s).chomp } )
87
+ @connection.request(method: :post, path: build_path(["create"], params), headers: { "X-Registry-Auth" => Base64.encode64(authentication.to_json.to_s).chomp } )
94
88
  elsif params.has_key? :fromSrc
95
89
  if params[:fromSrc].match(/^(http|https)/)
96
- connection.request(method: :post, path: build_path(["create"], params))
90
+ @connection.request(method: :post, path: build_path(["create"], params))
97
91
  else
98
92
  file = File.open(File.expand_path(params[:fromSrc]), "r")
99
93
  params[:fromSrc] = "-"
100
- response = connection.request(method: :post, path: build_path(["create"], params) , headers: {"Content-Type" => "application/x-tar"}, request_block: lambda { file.read(Excon.defaults[:chunk_size]).to_s} )
94
+ response = @connection.request(method: :post, path: build_path(["create"], params) , headers: {"Content-Type" => "application/x-tar"}, request_block: lambda { file.read(Excon.defaults[:chunk_size]).to_s} )
101
95
  file.close
102
96
  response
103
97
  end
104
98
  else
105
- connection.post(build_path(["create"], params))
99
+ @connection.post(build_path(["create"], params))
106
100
  end
107
101
  end
108
102
 
109
- def self.build path, params = {}, authentication = {}
103
+ def build path, params = {}, authentication = {}
110
104
  raise Docker::API::Error.new("Expected path or params[:remote]") unless path || params[:remote]
111
105
  validate Docker::API::InvalidParameter, Docker::API::BuildParams, params
112
106
 
113
107
  header = {"Content-type": "application/x-tar"}
114
108
  if authentication.keys.size > 0
115
109
  authentication.each_key do |server|
116
- auth = Docker::API::System.auth({username: authentication[server][:username] ,password:authentication[server][:password], serveraddress: server})
110
+ auth = Docker::API::System.new.auth({username: authentication[server][:username] ,password:authentication[server][:password], serveraddress: server})
117
111
  return auth unless [200, 204].include? auth.status
118
112
  end
119
113
  header.merge!({"X-Registry-Config": Base64.urlsafe_encode64(authentication.to_json.to_s).chomp})
@@ -121,20 +115,34 @@ module Docker
121
115
 
122
116
  begin
123
117
  file = File.open( File.expand_path( path ) , "r")
124
- response = connection.request(method: :post, path: build_path("/build", params), headers: header, request_block: lambda { file.read(Excon.defaults[:chunk_size]).to_s})
118
+ response = @connection.request(method: :post, path: build_path("/build", params), headers: header, request_block: lambda { file.read(Excon.defaults[:chunk_size]).to_s})
125
119
  file.close
126
120
  rescue
127
- response = connection.request(method: :post, path: build_path("/build", params), headers: header)
121
+ response = @connection.request(method: :post, path: build_path("/build", params), headers: header)
128
122
  end
129
123
  response
130
124
  end
131
125
 
132
- def self.delete_cache params = {}
126
+ def delete_cache params = {}
133
127
  validate Docker::API::InvalidParameter, [:all, "keep-storage", :filters], params
134
- connection.post(build_path("/build/prune", params))
128
+ @connection.post(build_path("/build/prune", params))
135
129
  end
136
130
 
137
- end
131
+ #################################################
132
+ # Items in this area to be removed before 1.0.0 #
133
+ #################################################
134
+ def base_path
135
+ "/images"
136
+ end
138
137
 
138
+ def inspect *args
139
+ return super.inspect if args.size == 0
140
+ warn "WARNING: #inspect is deprecated and will be removed in the future, please use #details instead."
141
+ name = args[0]
142
+ details(name)
143
+ end
144
+ #################################################
145
+
146
+ end
139
147
  end
140
148
  end