1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
|
# defaults to stderr, may be changed to file output (e.g in opentox-service)
$logger = OTLogger.new(STDERR)
$logger.level = Logger::DEBUG
module OpenTox
# Ruby interface
attr_accessor :data
# Create a new OpenTox object
# @param uri [optional,String] URI
# @return [OpenTox] OpenTox object
def initialize uri=nil
@data = {}
if uri
@data[:uri] = uri.to_s.chomp
get
else
@data[:uuid] = SecureRandom.uuid
@data[:uri] = File.join(service_uri, @data[:uuid])
end
end
# Object metadata (lazy loading)
# @return [Hash] Object metadata
def metadata force_update=false
get #if (@metadata.nil? or @metadata.empty? or force_update) and URI.accessible? @uri
@data
end
# Metadata values
# @param predicate [String] Predicate URI
# @return [Array, String] Predicate value(s)
def [](predicate)
predicate = predicate.to_s
return nil if metadata[predicate].nil?
metadata[predicate].size == 1 ? metadata[predicate].first : metadata[predicate]
end
# Set a metadata entry
# @param predicate [String] Predicate URI
# @param values [Array, String] Predicate value(s)
def []=(predicate,values)
predicate = predicate.to_s
@data[predicate] = [values].flatten
end
=begin
# Object parameters (lazy loading)
# {http://opentox.org/dev/apis/api-1.2/interfaces OpenTox API}
# @return [Hash] Object parameters
def parameters force_update=false
if (@parameters.empty? or force_update) and URI.accessible? @uri
get #if @rdf.empty? or force_update
params = {}
query = RDF::Query.new({
:parameter => {
RDF.type => RDF::OT.Parameter,
:property => :value,
}
})
query.execute(@rdf).each do |solution|
params[solution.parameter] = {} unless params[solution.parameter]
params[solution.parameter][solution.property] = solution.value
end
@parameters = params.values
end
@parameters
end
# Parameter value
# @param [String] title
# @return [String] value
def parameter_value title
@parameters.collect{|p| p[RDF::OT.paramValue] if p[RDF::DC.title] == title}.compact.first
end
=end
# Get object from webservice
# @param [String,optional] mime_type
def get mime_type="application/json"
bad_request_error "Mime type #{mime_type} is not supported. Please use 'application/json' (default), 'text/plain' (ntriples) or mime_type == 'application/rdf+xml'." unless mime_type == "application/json" or mime_type == "text/plain" or mime_type == "application/rdf+xml"
p @data[:uri]
response = RestClientWrapper.get(@data[:uri],{},{:accept => mime_type})
if URI.task?(response)
uri = wait_for_task response
response = RestClientWrapper.get(uri,{},{:accept => mime_type})
p uri
end
case mime_type
when 'application/json'
p response
@data = JSON.parse(response) if response
when "text/plain"
parse_ntriples response
when "application/rdf+xml"
parse_rdfxml response
end
end
=begin
# Post object to webservice (append to object), rarely useful and deprecated
# @deprecated
def post wait=true, mime_type="text/plain"
bad_request_error "Mime type #{mime_type} is not supported. Please use 'text/plain' (default) or 'application/rdf+xml'." unless mime_type == "text/plain" or mime_type == "application/rdf+xml"
case mime_type
when 'text/plain'
body = self.to_ntriples
when 'application/rdf+xml'
body = self.to_rdfxml
end
#Authorization.check_policy(@uri) if $aa[:uri]
uri = RestClientWrapper.post @uri.to_s, body, { :content_type => mime_type}
wait ? wait_for_task(uri) : uri
end
=end
# Save object at webservice (replace or create object)
def put wait=true, mime_type="application/json"
bad_request_error "Mime type #{mime_type} is not supported. Please use 'application/json' (default)." unless mime_type == "application/json" or mime_type == "text/plain" or mime_type == "application/rdf+xml"
@data[:created_at] = DateTime.now unless URI.accessible? @data[:uri]
#@metadata[RDF::DC.modified] = DateTime.now
@data[:uri] ? @data[:uri] = uri.to_s.chomp : @data[:uri] = File.join(service_uri, SecureRandom.uuid)
case mime_type
when 'text/plain'
body = self.to_ntriples
when 'application/rdf+xml'
body = self.to_rdfxml
when 'application/json'
body = self.to_json
end
uri = RestClientWrapper.put @data[:uri], body, { :content_type => mime_type}
wait ? wait_for_task(uri) : uri
end
# Delete object at webservice
def delete
RestClientWrapper.delete(@data[:uri])
#Authorization.delete_policies_from_uri(@data[:uri]) if $aa[:uri]
end
def service_uri
self.class.service_uri
end
def create_rdf
#$logger.debug "#{eval("RDF::OT."+self.class.to_s.split('::').last)}\n"
@rdf = RDF::Graph.new
# DG: since model is no self.class anymore
@metadata[RDF.type] ||= (eval("RDF::OT."+self.class.to_s.split('::').last) =~ /Lazar|Generic/) ? RDF::URI.new(RDF::OT.Model) : RDF::URI.new(eval("RDF::OT."+self.class.to_s.split('::').last))
#@metadata[RDF.type] ||= RDF::URI.new(eval("RDF::OT."+self.class.to_s.split('::').last))
@metadata[RDF::DC.date] ||= DateTime.now
# DG: uri in object should be in brackets, otherwise query for uri-list ignores the object.
# see: http://www.w3.org/TR/rdf-testcases/#sec-uri-encoding
@metadata.each do |predicate,values|
[values].flatten.each{ |value| @rdf << [RDF::URI.new(@data[:uri]), predicate, (URI.valid?(value) ? RDF::URI.new(value) : value)] unless value.nil? }
end
@parameters.each do |parameter|
p_node = RDF::Node.new
@rdf << [RDF::URI.new(@data[:uri]), RDF::OT.parameters, p_node]
@rdf << [p_node, RDF.type, RDF::OT.Parameter]
parameter.each { |k,v| @rdf << [p_node, k, v] unless v.nil?}
end
end
# as defined in opentox-client.rb
RDF_FORMATS.each do |format|
# rdf parse methods for all formats e.g. parse_rdfxml
send :define_method, "parse_#{format}".to_sym do |rdf|
@rdf = RDF::Graph.new
RDF::Reader.for(format).new(rdf) do |reader|
reader.each_statement{ |statement| @rdf << statement }
end
# return values as plain strings instead of RDF objects
@metadata = @rdf.to_hash[RDF::URI.new(@data[:uri])].inject({}) { |h, (predicate, values)| h[predicate] = values.collect{|v| v.to_s}; h }
end
=begin
# rdf serialization methods for all formats e.g. to_rdfxml
send :define_method, "to_#{format}".to_sym do
create_rdf
# if encoding is used iteration is necessary
# see: http://rubydoc.info/github/ruby-rdf/rdf/RDF/NTriples/Writer
RDF::Writer.for(format).buffer(:encoding => Encoding::ASCII) do |writer|
@rdf.each_statement do |statement|
writer << statement
end
end
end
=end
end
# @return [String] converts object to turtle-string
def to_turtle # redefined to use prefixes (not supported by RDF::Writer)
prefixes = {:rdf => "http://www.w3.org/1999/02/22-rdf-syntax-ns#"}
['OT', 'DC', 'XSD', 'OLO'].each{|p| prefixes[p.downcase.to_sym] = eval("RDF::#{p}.to_s") }
create_rdf
RDF::Turtle::Writer.for(:turtle).buffer(:prefixes => prefixes) do |writer|
writer << @rdf
end
end
def to_json
@data.to_json
end
# @return [String] converts OpenTox object into html document (by first converting it to a string)
def to_html
to_turtle.to_html
end
# short access for metadata keys title, description and type
[ :title , :description , :type , :uri, :uuid ].each do |method|
send :define_method, method do
self.data[method]
end
send :define_method, "#{method}=" do |value|
self.data[method] = value
end
end
# define class methods within module
def self.included(base)
base.extend(ClassMethods)
end
module ClassMethods
def service_uri
service = self.to_s.split('::')[1].downcase
eval("$#{service}[:uri]")
rescue
bad_request_error "$#{service}[:uri] variable not set. Please set $#{service}[:uri] or use an explicit uri as first constructor argument "
end
def subjectid
RestClientWrapper.subjectid
end
def subjectid=(subjectid)
RestClientWrapper.subjectid = subjectid
end
end
# create default OpenTox classes with class methods
# (defined in opentox-client.rb)
CLASSES.each do |klass|
c = Class.new do
include OpenTox
def self.all
uris = RestClientWrapper.get(service_uri, {},{:accept => 'text/uri-list'}).split("\n").compact
uris.collect{|uri| self.new(uri)}
end
#@example fetching a model
# OpenTox::Model.find(<model-uri>) -> model-object
def self.find uri
URI.accessible?(uri) ? self.new(uri) : nil
end
def self.create metadata
object = self.new
object.data = metadata
object.put
object
end
def self.find_or_create metadata
uris = RestClientWrapper.get(service_uri,{:query => @data},{:accept => "text/uri-list"}).split("\n")
uris.empty? ? self.create(@data) : self.new(uris.first)
end
end
OpenTox.const_set klass,c
end
end
# from overwrite.rb
class String
# encloses URI in text with with link tag
# @return [String] new text with marked links
def link_urls
self.gsub(/(?i)http(s?):\/\/[^\r\n\s']*/, '<a href="\0">\0</a>')
end
# produces a html page for making web services browser friendly
# format of text (=string params) is preserved (e.g. line breaks)
# urls are marked as links
#
# @param related_links [optional,String] uri on related resources
# @param description [optional,String] general info
# @param png_image [optional,String] imagename
# @return [String] html page
def to_html(related_links=nil, description=nil, png_image=nil )
# TODO add title as parameter
title = nil #$sinatra.to($sinatra.request.env['PATH_INFO'], :full) if $sinatra
html = "<html><body>"
html << "<title>"+title+"</title>" if title
#html += "<img src=\""+OT_LOGO+"\"><\/img><body>"
html << "<h3>Description</h3><pre><p>"+description.link_urls+"</p></pre>" if description
html << "<h3>Related links</h3><pre><p>"+related_links.link_urls+"</p></pre>" if related_links
html << "<h3>Content</h3>" if description || related_links
html << "<pre><p style=\"padding:15px; border:10px solid \#C5C1E4\">"
html << "<img src=\"data:image/png;base64,#{Base64.encode64(png_image)}\">\n" if png_image
html << self.link_urls
html << "</p></pre></body></html>"
html
end
def uri?
URI.valid?(self)
end
end
module Kernel
=begin
# overwrite backtick operator to catch system errors
# Override raises an error if _cmd_ returns a non-zero exit status. CH: I do not understand this comment
# Returns stdout if _cmd_ succeeds. Note that these are simply concatenated; STDERR is not inline. CH: I do not understand this comment
def ` cmd
stdout, stderr = ''
status = Open4::popen4(cmd) do |pid, stdin_stream, stdout_stream, stderr_stream|
stdout = stdout_stream.read
stderr = stderr_stream.read
end
internal_server_error "`" + cmd + "` failed.\n" + stdout + stderr unless status.success?
return stdout
rescue
internal_server_error $!.message
end
=end
# @return [String] uri of task result, if task fails, an error according to task is raised
def wait_for_task uri
if URI.task?(uri)
t = OpenTox::Task.new uri
t.wait
unless t.completed?
error = OpenTox::RestClientWrapper.known_errors.select{|error| error[:code] == t.code}.first
error_method = error ? error[:method] : :internal_server_error
report = t.error_report
error_message = report ? report[:message] : $!.message
error_cause = report ? report[:errorCause] : nil
Object.send(error_method,error_message,t.uri,error_cause)
end
uri = t.resultURI
end
uri
end
end
module URI
def self.compound? uri
uri =~ /compound/ and URI.valid? uri
end
def self.task? uri
uri =~ /task/ and URI.valid? uri
end
def self.dataset? uri
uri =~ /dataset/ and URI.accessible? uri
end
def self.model? uri
uri =~ /model/ and URI.accessible? uri
end
def self.ssl? uri
URI.parse(uri).instance_of? URI::HTTPS
end
# @return [Boolean] checks if resource exists by making a HEAD-request
def self.accessible?(uri)
parsed_uri = URI.parse(uri + (OpenTox::RestClientWrapper.subjectid ? "?subjectid=#{CGI.escape OpenTox::RestClientWrapper.subjectid}" : ""))
http_code = URI.task?(uri) ? 600 : 400
http = Net::HTTP.new(parsed_uri.host, parsed_uri.port)
unless (URI.ssl? uri) == true
http = Net::HTTP.new(parsed_uri.host, parsed_uri.port)
request = Net::HTTP::Head.new(parsed_uri.request_uri)
http.request(request).code.to_i < http_code
else
http = Net::HTTP.new(parsed_uri.host, parsed_uri.port)
http.use_ssl = true
http.verify_mode = OpenSSL::SSL::VERIFY_NONE
request = Net::HTTP::Head.new(parsed_uri.request_uri)
http.request(request).code.to_i < http_code
end
rescue
false
end
def self.valid? uri
u = URI.parse(uri)
u.scheme!=nil and u.host!=nil
rescue URI::InvalidURIError
false
end
end
|