Class: Job

Inherits:
Sequel::Model
  • Object
show all
Includes:
ASModel
Defined in:
backend/app/model/job.rb,
frontend/app/models/job.rb

Defined Under Namespace

Classes: JobFileStore

Class Method Summary (collapse)

Instance Method Summary (collapse)

Methods included from ASModel

all_models, included, update_publish_flag, update_suppressed_flag

Methods included from JSONModel

JSONModel, #JSONModel, add_error_handler, all, allow_unmapped_enum_value, backend_url, client_mode?, custom_validations, destroy_model, enum_default_value, enum_values, handle_error, init, load_schema, #models, models, parse_jsonmodel_ref, parse_reference, repository, repository_for, schema_src, set_repository, strict_mode, strict_mode?, with_repository

Constructor Details

- (Job) initialize(job_type, job_data, files_to_import, job_params = {})

Returns a new instance of Job



3
4
5
6
7
8
9
10
11
12
13
14
 
# File 'frontend/app/models/job.rb', line 3

def initialize(job_type, job_data, files_to_import, job_params = {})

  if job_type == 'import_job'
    job_data[:filenames] = files_to_import.keys
  end

  @job = JSONModel(:job).from_hash(:job_type => job_type,
                                   :job => job_data,
                                   :job_params =>  ASUtils.to_json(job_params) )

  @files = files_to_import
end

Class Method Details

+ (Object) active 



41
42
43
 
# File 'frontend/app/models/job.rb', line 41

def self.active
  JSONModel::HTTP::get_json(JSONModel(:job).uri_for("active"), "resolve[]" => "repository")
end

+ (Object) archived(page) 



46
47
48
 
# File 'frontend/app/models/job.rb', line 46

def self.archived(page)
  JSONModel::HTTP::get_json(JSONModel(:job).uri_for("archived"), :page => page, "resolve[]" => "repository")
end

+ (Object) available_import_types 



73
74
75
 
# File 'frontend/app/models/job.rb', line 73

def self.available_import_types
  JSONModel::HTTP.get_json(JSONModel(:job).uri_for("import_types"))
end

+ (Object) available_types 



68
69
70
 
# File 'frontend/app/models/job.rb', line 68

def self.available_types
  JSONModel::HTTP.get_json(JSONModel(:job).uri_for("types"))
end

+ (Object) cancel(id) 



61
62
63
64
65
 
# File 'frontend/app/models/job.rb', line 61

def self.cancel(id)
  response = JSONModel::HTTP.post_form("#{JSONModel(:job).uri_for(id)}/cancel")

  ASUtils.json_parse(response.body)
end

+ (Object) create_from_json(json, opts = {}) 



75
76
77
78
79
80
81
82
83
84
85
 
# File 'backend/app/model/job.rb', line 75

def self.create_from_json(json, opts = {})
  if json.job_params == "null" 
    json.job_params = ""
  end
  
  super(json, opts.merge(:time_submitted => Time.now,
                         :owner_id => opts.fetch(:user).id,
                         :job_blob => ASUtils.to_json(json.job),
                         :job_params => ASUtils.to_json(json.job_params) 
                        ))
end

+ (Object) log(id, offset = 0, &block) 



51
52
53
 
# File 'frontend/app/models/job.rb', line 51

def self.log(id, offset = 0, &block)
  JSONModel::HTTP::stream("#{JSONModel(:job).uri_for(id)}/log", {:offset => offset}, &block)
end

+ (Object) records(id, page) 



56
57
58
 
# File 'frontend/app/models/job.rb', line 56

def self.records(id, page)
  JSONModel::HTTP::get_json("#{JSONModel(:job).uri_for(id)}/records", :page => page, "resolve[]" => "record")
end

+ (Object) sequel_to_jsonmodel(objs, opts = {}) 



88
89
90
91
92
93
94
95
96
97
 
# File 'backend/app/model/job.rb', line 88

def self.sequel_to_jsonmodel(objs, opts = {})
  jsons = super
  jsons.zip(objs).each do |json, obj|
    json.job = JSONModel(json.job_type.intern).from_json(obj.job_blob)
    json.owner = obj.owner.username
    json.queue_position = obj.queue_position if obj.status === "queued"
  end

  jsons
end

Instance Method Details

- (Object) add_file(io) 



105
106
107
 
# File 'backend/app/model/job.rb', line 105

def add_file(io)
  add_job_file(JobFile.new(:file_path => file_store.store(io)))
end

- (Object) cancel! 



156
157
158
159
160
161
 
# File 'backend/app/model/job.rb', line 156

def cancel!
  if ["queued", "running"].include? self.status
    self.status = "canceled"
    self.save
  end
end

- (Object) file_store 



100
101
102
 
# File 'backend/app/model/job.rb', line 100

def file_store
  @file_store ||= JobFileStore.new("#{job_type}_#{id}")
end

- (Object) finish(status) 



146
147
148
149
150
151
152
153
 
# File 'backend/app/model/job.rb', line 146

def finish(status)
  file_store.close_output

  self.reload
  self.status = "#{status}"
  self.time_finished = Time.now
  self.save
end

- (Object) get_output_stream(offset = 0) 



115
116
117
118
119
120
121
 
# File 'backend/app/model/job.rb', line 115

def get_output_stream(offset = 0)
  begin
    file_store.get_output_stream(offset)
  rescue
    [StringIO.new(""), 0]
  end
end

- (Object) queue_position 



138
139
140
141
142
143
 
# File 'backend/app/model/job.rb', line 138

def queue_position
  DB.open do |db|
    job_id = self.id
    db[:job].where { id < job_id }.where(:status => "queued").count
  end
end

- (Object) record_created_uris(uris) 



124
125
126
127
128
 
# File 'backend/app/model/job.rb', line 124

def record_created_uris(uris)
  uris.each do |uri|
    add_created_record(:record_uri => uri)
  end
end

- (Object) record_modified_uris(uris) 



131
132
133
134
135
 
# File 'backend/app/model/job.rb', line 131

def record_modified_uris(uris)
  uris.each do |uri|
    add_modified_record(:record_uri => uri)
  end
end

- (Object) upload 



17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
 
# File 'frontend/app/models/job.rb', line 17

def upload
  unless @files.empty?

    upload_files = @files.each_with_index.map {|file, i|
      (original_filename, stream) = file
      ["files[#{i}]", UploadIO.new(stream, "text/plain", original_filename)]
    }

    response = JSONModel::HTTP.post_form("#{JSONModel(:job).uri_for(nil)}_with_files",
                                         Hash[upload_files].merge('job' => @job.to_json),
                                         :multipart_form_data)

    ASUtils.json_parse(response.body)

  else

    @job.save

    {:uri => @job.uri}
  end

end

- (Object) write_output(s) 



110
111
112
 
# File 'backend/app/model/job.rb', line 110

def write_output(s)
  file_store.write_output(s)
end