Class: Mutx::Database::MongoConnector

Inherits:
Object
  • Object
show all
Defined in:
lib/mutx/database/mongo_connector.rb

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(opts = {host: "localhost", port: 27017, username: nil, pass: nil}) ⇒ MongoConnector

include Mongo



10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
 
# File 'lib/mutx/database/mongo_connector.rb', line 10

def initialize(opts={host: "localhost", port: 27017, username: nil, pass: nil})
  project_name = Dir.pwd.split("/").last
  mongo_connection = MongoConnection.instance
  mongo_connection.client(host: opts[:host],
                          port: opts[:port],
                          database: "#{project_name}_mutx",
                          username: opts[:username],
                          password: opts[:pass])

  $db = mongo_connection.db
  set_task_collection
  set_custom_param_collection
  set_config_collection
  set_results_collection
  set_commits_collection
  set_documentation_collection
  set_input_collection
  set_repos_collection
  set_logger
end

Class Method Details

.active_tasks ⇒ Object 



376
377
378
 
# File 'lib/mutx/database/mongo_connector.rb', line 376

def self.active_tasks
  self.all_tasks
end

.all_repos ⇒ Object

REPOS



418
419
420
421
422
 
# File 'lib/mutx/database/mongo_connector.rb', line 418

def self.all_repos
  res = $repos.find({})
  res.to_a if res.respond_to? :to_a
  res
end

.all_results ⇒ Object

Returns all result $return [Array] results from results coll



598
599
600
 
# File 'lib/mutx/database/mongo_connector.rb', line 598

def self.all_results
  $results.find({}).sort('_id' => -1).to_a
end

.all_results_ids ⇒ Object 



602
603
604
 
# File 'lib/mutx/database/mongo_connector.rb', line 602

def self.all_results_ids
  $results.find({},{"_id" => 1}, :sort => ['_id', -1]).to_a
end

.all_tasks ⇒ Object

Returns all active tasks



286
287
288
 
# File 'lib/mutx/database/mongo_connector.rb', line 286

def self.all_tasks
  self.tasks
end

.all_tests ⇒ Object 



290
291
292
 
# File 'lib/mutx/database/mongo_connector.rb', line 290

def self.all_tests
  self.tasks "test"
end

.clean_documentation ⇒ Object

Removes all documents of documentation from the DB



123
124
125
126
127
 
# File 'lib/mutx/database/mongo_connector.rb', line 123

def self.clean_documentation
  Mutx::Support::Log.debug "Cleanning db documentation collection" if Mutx::Support::Log
  $documentation.drop
  # $db.drop_collection("documentation")
end

.close ⇒ Object 



56
57
58
 
# File 'lib/mutx/database/mongo_connector.rb', line 56

def self.close
  MongoConnection.instance.close
end

.collections ⇒ Object

Returns a list of collections



186
187
188
 
# File 'lib/mutx/database/mongo_connector.rb', line 186

def self.collections
  ["tasks","results","custom_params","commit","configuration"]
end

.configuration ⇒ Object 



632
633
634
635
 
# File 'lib/mutx/database/mongo_connector.rb', line 632

def self.configuration
  Mutx::Support::Log.debug "Getting db configuration data" if Mutx::Support::Log
  $configuration.find({}).to_a.first
end

.connected? ⇒ Boolean

COMMONS

Returns:

  • (Boolean) 


167
168
169
170
171
172
173
 
# File 'lib/mutx/database/mongo_connector.rb', line 167

def self.connected?
  begin
    $db and true
  rescue
    false
  end
end

.cron_tasks ⇒ Object

Get cronneable tasks



278
279
280
281
282
283
 
# File 'lib/mutx/database/mongo_connector.rb', line 278

def self.cron_tasks
  Mutx::Support::Log.debug "Getting cronneable tasks" if Mutx::Support::Log
  criteria = {}
  criteria["cronneable"]="on"
  $tasks.find(criteria).sort("last_result" => -1).to_a
end

.custom_param_for_name(custom_param_name) ⇒ Object 



490
491
492
493
 
# File 'lib/mutx/database/mongo_connector.rb', line 490

def self.custom_param_for_name custom_param_name
  Mutx::Support::Log.debug "Getting db custom param data for custom param name [#{custom_param_name}]" if Mutx::Support::Log
  $custom_params.find({"name" => custom_param_name}).to_a.first
end

.custom_params_list ⇒ Object

CUSTOM PARAMS



457
458
459
460
 
# File 'lib/mutx/database/mongo_connector.rb', line 457

def self.custom_params_list
  Mutx::Support::Log.debug "Getting db custom params list" if Mutx::Support::Log
  $custom_params.find({}).to_a
end

.delete_custom_param(custom_param_id) ⇒ Object 



504
505
506
507
508
509
 
# File 'lib/mutx/database/mongo_connector.rb', line 504

def self.delete_custom_param custom_param_id
  Mutx::Support::Log.debug "Deleting db custom param for custom param id [#{custom_param_id}]" if Mutx::Support::Log
  $custom_params.delete_one({"_id" => custom_param_id})

  self.update_tasks_with_custom_param_id(custom_param_id)
end

.delete_started_result(result_id) ⇒ Object 



342
343
344
345
346
347
348
 
# File 'lib/mutx/database/mongo_connector.rb', line 342

def self.delete_started_result result_id
  Mutx::Support::Log.debug "Deletting db started result with id #{result_id}" if Mutx::Support::Log
  #Fix because MD5
  #task_id = task_id.to_i if task_id.respond_to? :to_i
  res = $results.delete_one({"_id" => result_id})
  res.n==1
end

.delete_task(task_id) ⇒ Object 



380
381
382
383
384
385
386
 
# File 'lib/mutx/database/mongo_connector.rb', line 380

def self.delete_task task_id
  Mutx::Support::Log.debug "Deletting db task with id #{task_id}" if Mutx::Support::Log
  #Fix because MD5
  #task_id = task_id.to_i if task_id.respond_to? :to_i
  res = $tasks.delete_one({"_id" => task_id})
  res.n==1
end

.drop_collections(hard = false) ⇒ Object 



190
191
192
193
194
195
196
 
# File 'lib/mutx/database/mongo_connector.rb', line 190

def self.drop_collections hard=false
  collections_to_drop = self.collections
  ["custom_params","tasks"].each{|col| collections_to_drop.delete(col)} unless hard
  collections_to_drop.each do |collection|
    self..drop_collection(collection) if collection != "documentation"
  end
end

.ensure_int(value) ⇒ Object

Returns value as Fixnum if it is not $param [Object] value $return [Fixnum]



591
592
593
594
 
# File 'lib/mutx/database/mongo_connector.rb', line 591

def self.ensure_int(value)
  value = value.to_i if value.respond_to? :to_i
  value
end

.exist_custom_param_id?(param_id) ⇒ Boolean

Returns:

  • (Boolean) 


499
500
501
502
 
# File 'lib/mutx/database/mongo_connector.rb', line 499

def self.exist_custom_param_id? param_id
  # !$custom_params.find({"_id" => param_id}).nil?
  $custom_params.find({"_id" => param_id})
end

.exist_custom_param_name?(name) ⇒ Boolean

Returns:

  • (Boolean) 


495
496
497
 
# File 'lib/mutx/database/mongo_connector.rb', line 495

def self.exist_custom_param_name? name
  !self.param_id_for_name(name).nil?
end

.exist_task_with_custom_param_id?(custom_param_id) ⇒ Boolean

Returns:

  • (Boolean) 


517
518
519
 
# File 'lib/mutx/database/mongo_connector.rb', line 517

def self.exist_task_with_custom_param_id? custom_param_id
  !self.tasks_with_custom_param_id(custom_param_id).empty?
end

.file_attached(result_id) ⇒ Object 



368
369
370
 
# File 'lib/mutx/database/mongo_connector.rb', line 368

def self.file_attached result_id
  $results.update_one({"_id" => result_id}, {"$set" => {"file_attached" => "yes"}})
end

.find_results_for_key(key) ⇒ Object 



606
607
608
 
# File 'lib/mutx/database/mongo_connector.rb', line 606

def self.find_results_for_key key
  $results.find({$or => [{"task.name" => /#{key}/}, {"execution_name" => /#{key}/ }, {"summary" => /#{key}/ }, {"command" => /#{key}/ }]}).to_a
end

.find_results_for_status(status) ⇒ Object 



619
620
621
 
# File 'lib/mutx/database/mongo_connector.rb', line 619

def self.find_results_for_status status
  $results.find({$or => [{"summary" => /#{status}/}, {"status" => /#{status}/ }]},{"_id" => 1}).to_a
end

.find_results_for_task(task_name) ⇒ Object 



614
615
616
617
 
# File 'lib/mutx/database/mongo_connector.rb', line 614

def self.find_results_for_task task_name
  task_id = self.task_id_for task_name
  self.results_for task_id
end

.force_close ⇒ Object 



52
53
54
 
# File 'lib/mutx/database/mongo_connector.rb', line 52

def self.force_close
  $client.close if $client
end

.generate_id ⇒ Object 



175
176
177
178
 
# File 'lib/mutx/database/mongo_connector.rb', line 175

def self.generate_id
  value = Time.now.to_f.to_s.gsub( ".","")[0..12].to_i
  Digest::MD5.hexdigest(value.to_s) #Added MD5 to generate a mongo id
end

.generate_token ⇒ Object 



180
181
182
183
 
# File 'lib/mutx/database/mongo_connector.rb', line 180

def self.generate_token
  value = Time.now.to_f.to_s.gsub( ".","")[0..12].to_i + 10
  Digest::MD5.hexdigest(value.to_s)
end

.get_all_documentation ⇒ Object

Return an array with all documents of documentation



136
137
138
139
 
# File 'lib/mutx/database/mongo_connector.rb', line 136

def self.get_all_documentation
  Mutx::Support::Log.debug "getting db all documentation" if Mutx::Support::Log
  $documentation.find().to_a
end

.get_custom_param(custom_param_id) ⇒ Object

Returns the entire record for a given id $param [String] custom_param_id $return [Hash] all custom param data



478
479
480
481
482
 
# File 'lib/mutx/database/mongo_connector.rb', line 478

def self.get_custom_param custom_param_id
  Mutx::Support::Log.debug "Getting db custom param data for custom param id #{custom_param_id}" if Mutx::Support::Log

  res = $custom_params.find({"_id" => custom_param_id}).to_a.first
end

.help_body(page) ⇒ Object

Returns the body html of a page



142
143
144
145
146
 
# File 'lib/mutx/database/mongo_connector.rb', line 142

def self.help_body page
  Mutx::Support::Log.debug "getting db help body" if Mutx::Support::Log
  result = $documentation.find({"title" => page}).to_a.first
  result["body"].to_s if result != nil
end

.help_search(title) ⇒ Object

Returns a document from the DB for a certain title



156
157
158
159
 
# File 'lib/mutx/database/mongo_connector.rb', line 156

def self.help_search title
  Mutx::Support::Log.debug "Searching on db help colection for title #{title}" if Mutx::Support::Log
  $documentation.find({:$or => [{ "title" => /#{title}/ },{ "title" => /#{title.upcase}/ },{ "body" => /#{title}/ }]}).to_a
end

.help_title(page) ⇒ Object

Returns the title of a page



149
150
151
152
153
 
# File 'lib/mutx/database/mongo_connector.rb', line 149

def self.help_title page
  Mutx::Support::Log.debug "getting db help title" if Mutx::Support::Log        
  result = $documentation.find({"title" => page}).to_a.first
  result["title"].to_s.gsub('_', ' ').capitalize if result != nil
end

.input_data_for_id(id) ⇒ Object 



407
408
409
410
411
 
# File 'lib/mutx/database/mongo_connector.rb', line 407

def self.input_data_for_id(id)
  res = $inputs.find({"_id" => id})
  res = res.to_a.first if res.respond_to? :to_a
  res
end

.insert_commit(commit_info) ⇒ Object

Saves commit information $param [Hash] commit_info = => Fixnum, “commit_id” => String, “info” => String



208
209
210
 
# File 'lib/mutx/database/mongo_connector.rb', line 208

def self.insert_commit commit_info
  $commits.insert_one({"_id" => self.generate_id, "log" => commit_info})
end

.insert_config(config_object) ⇒ Object

3 CONFIG



627
628
629
630
 
# File 'lib/mutx/database/mongo_connector.rb', line 627

def self.insert_config config_object
  Mutx::Support::Log.debug "db insert configuration [#{document}]" if Mutx::Support::Log
  $configuration.insert_one(config_object)
end

.insert_custom_param(custom_param_data) ⇒ Object 



462
463
464
465
 
# File 'lib/mutx/database/mongo_connector.rb', line 462

def self.insert_custom_param custom_param_data
  Mutx::Support::Log.debug "Inserting custom param [#{custom_param_data}]" if Mutx::Support::Log
  $custom_params.insert_one(custom_param_data)
end

.insert_documentation(document) ⇒ Object

Inserts a document of documentation in the DB



130
131
132
133
 
# File 'lib/mutx/database/mongo_connector.rb', line 130

def self.insert_documentation document
  Mutx::Support::Log.debug "db insert documentation [#{document}]" if Mutx::Support::Log
  $documentation.insert_one(document)
end

.insert_input(input_data) ⇒ Object 



402
403
404
405
 
# File 'lib/mutx/database/mongo_connector.rb', line 402

def self.insert_input input_data
  Mutx::Support::Log.debug "Inserting input [#{input_data}]" if Mutx::Support::Log
  $inputs.insert_one(input_data)
end

.insert_repo(repo_data) ⇒ Object 



424
425
426
427
428
 
# File 'lib/mutx/database/mongo_connector.rb', line 424

def self.insert_repo repo_data
  res = $repos.find({"repo_name" => repo_data["repo_name"]})
  (Mutx::Support::Log.debug "Inserting repo [#{repo_data}]" if Mutx::Support::Log
  $repos.insert_one(repo_data)) if res.to_a.empty?
end

.insert_result(result_data) ⇒ Object

Creates a result data andc returns de id for that register $param [Hash] execution_data $return [String] id for created result



543
544
545
546
547
548
549
550
 
# File 'lib/mutx/database/mongo_connector.rb', line 543

def self.insert_result(result_data)
  begin
    $results.insert_one(result_data)
    true
  rescue
    false
  end
end

.insert_task(task_data) ⇒ Object

Inserts a task in tasks collection $param [Hash] task_data (see task_data_structure method)



228
229
230
231
 
# File 'lib/mutx/database/mongo_connector.rb', line 228

def self.insert_task task_data
  Mutx::Support::Log.debug "Inserting task [#{task_data}]" if Mutx::Support::Log
  $tasks.insert_one(task_data)
end

.last_commit ⇒ Object

Returns last saved commit info $return [Hash] if exist



214
215
216
217
218
219
220
 
# File 'lib/mutx/database/mongo_connector.rb', line 214

def self.last_commit
  Mutx::Support::Log.debug "Getting last commit" if Mutx::Support::Log
  data = $commits.find({}).to_a || []
  unless data.empty?
    data.last["log"]
  end
end

.last_notified(quantity) ⇒ Object

get last N notified results



363
364
365
366
 
# File 'lib/mutx/database/mongo_connector.rb', line 363

def self.last_notified(quantity) #get last N notified results
  quantity = 5 if ( (quantity.to_i.eql? 0) || (quantity.to_i <= 0) ) 
  $results.find({"notified" => "yes"}).limit(quantity.to_i).sort({"started_at" => -1}).to_a
end

.last_result_for_task(task_id) ⇒ Object 



610
611
612
 
# File 'lib/mutx/database/mongo_connector.rb', line 610

def self.last_result_for_task task_id
  $results.find({}, :sort => ['_id', -1])
end

.mark_notified(result_id) ⇒ Object 



359
360
361
 
# File 'lib/mutx/database/mongo_connector.rb', line 359

def self.mark_notified result_id
  $results.update_one({"_id" => result_id}, {"$set" => {"notified" => "yes"}})
end

.only_running_for_task(task_name) ⇒ Object 



337
338
339
340
 
# File 'lib/mutx/database/mongo_connector.rb', line 337

def self.only_running_for_task task_name
  Mutx::Support::Log.debug "Getting db running for task name #{task_name}" if Mutx::Support::Log
  $results.find({"status" => "running", "task.name" => task_name}).to_a
end

.only_started_for_task(task_name) ⇒ Object 



320
321
322
323
 
# File 'lib/mutx/database/mongo_connector.rb', line 320

def self.only_started_for_task task_name
  Mutx::Support::Log.debug "Getting db running for task name #{task_name}" if Mutx::Support::Log
  $results.find({"status" => "started", "task.name" => task_name}).to_a
end

.param_id_for_name(custom_param_name) ⇒ Object 



484
485
486
487
488
 
# File 'lib/mutx/database/mongo_connector.rb', line 484

def self.param_id_for_name custom_param_name
  Mutx::Support::Log.debug "Getting db custom param id for custom param name [#{custom_param_name}]" if Mutx::Support::Log
  res = self.custom_param_for_name(custom_param_name)
  res["_id"] if res
end

.repo_data_for_name(name) ⇒ Object 



444
445
446
447
448
 
# File 'lib/mutx/database/mongo_connector.rb', line 444

def self.repo_data_for_name(name)
  res = $repos.find({"repo_name" => name})
  res = res.to_a.first if res.respond_to? :to_a
  res
end

.required_params_ids ⇒ Object 



513
514
515
 
# File 'lib/mutx/database/mongo_connector.rb', line 513

def self.required_params_ids
  $custom_params.find({"required" => true},{:fields => ["_id"]})
end

.result_data_for_id(result_id) ⇒ Object 



571
572
573
574
575
576
577
 
# File 'lib/mutx/database/mongo_connector.rb', line 571

def self.result_data_for_id(result_id)
  #FIXED
  #result_id = self.ensure_int(result_id) #Cant convert MD5 to integer
  res = $results.find({"_id" => result_id})
  res = res.to_a.first if res.respond_to? :to_a
  res
end

.results_for(task_id) ⇒ Object

Returns all results for a given task_id



553
554
555
556
557
558
 
# File 'lib/mutx/database/mongo_connector.rb', line 553

def self.results_for task_id
  #FIXED
  #$results.find({"task.id" => ensure_int(task_id)}).sort("started_at" => -1).to_a #Cant convert MD5 to integer
  $results.find({"task.id" => (task_id)}).sort("started_at" => -1).to_a

end

.running(type) ⇒ Object 



307
308
309
310
311
312
 
# File 'lib/mutx/database/mongo_connector.rb', line 307

def self.running type
  Mutx::Support::Log.debug "Getting db running tasks" if Mutx::Support::Log
  $results.find({"status" => /started|running/, "task.type" => type}).to_a.map do |result|
    self.task_data_for result["task"]["id"]
  end.uniq
end

.running_for_task(task_name) ⇒ Object

Cron_start



315
316
317
318
 
# File 'lib/mutx/database/mongo_connector.rb', line 315

def self.running_for_task task_name
  Mutx::Support::Log.debug "Getting db running for task name #{task_name}" if Mutx::Support::Log
  $results.find({"status" => /started|running/, "task.name" => task_name}).to_a
end

.running_now ⇒ Object 



302
303
304
305
 
# File 'lib/mutx/database/mongo_connector.rb', line 302

def self.running_now
  Mutx::Support::Log.debug "Getting db running tasks" if Mutx::Support::Log
  $results.find({"status" => /started|running/}).to_a
end

.running_results ⇒ Object 



583
584
585
 
# File 'lib/mutx/database/mongo_connector.rb', line 583

def self.running_results
  $results.find({"status" => /running|started/}).to_a
end

.running_results_for_task_id(task_id) ⇒ Object 



579
580
581
 
# File 'lib/mutx/database/mongo_connector.rb', line 579

def self.running_results_for_task_id task_id
  $results.find({"task.id" => task_id, "status" => /running|started/}).sort("started_at" => -1).to_a
end

.running_tasks ⇒ Object 



294
295
296
 
# File 'lib/mutx/database/mongo_connector.rb', line 294

def self.running_tasks
  self.running "task"
end

.running_tests ⇒ Object 



298
299
300
 
# File 'lib/mutx/database/mongo_connector.rb', line 298

def self.running_tests
  self.running "test"
end

.started! ⇒ Object

def self.update_only_started

$results.update_many({"status" => "started"}, {"$set" => {"status" => "never_started"}})

end



329
330
331
 
# File 'lib/mutx/database/mongo_connector.rb', line 329

def self.started!
  $results.find({"status" => "started"}).to_a
end

.task_data_for(task_id) ⇒ Object

Returns the entire record for a given task name $param [String] task_name $return [Hash] all task data



247
248
249
250
251
252
 
# File 'lib/mutx/database/mongo_connector.rb', line 247

def self.task_data_for task_id
  #task_id = task_id.to_i if task_id.respond_to? :to_i
  res = $tasks.find({"_id" => task_id}).to_a.first
  Mutx::Support::Log.debug "Getting db task data for task id #{task_id} => res = [#{res}]" if Mutx::Support::Log
  res
end

.task_data_for_name(task_name) ⇒ Object 



254
255
256
257
 
# File 'lib/mutx/database/mongo_connector.rb', line 254

def self.task_data_for_name(task_name)
  Mutx::Support::Log.debug "Getting db task data for name #{task_name}" if Mutx::Support::Log
  $tasks.find({"name" => task_name}).to_a.first
end

.task_id_for(task_name, type = nil) ⇒ Object

Returns the _id for a given task name $param [String] task_name $return [String] _id



262
263
264
265
266
267
268
 
# File 'lib/mutx/database/mongo_connector.rb', line 262

def self.task_id_for task_name, type=nil
  Mutx::Support::Log.debug "Getting db task id for task name #{task_name} [type: #{type}]" if Mutx::Support::Log
  criteria = {"name" => task_name}
  criteria["type"] = type if type
  res = $tasks.find(criteria, {:fields => ["_id"]}).to_a.first
  res["_id"] if res
end

.tasks(type = nil) ⇒ Object 



270
271
272
273
274
275
 
# File 'lib/mutx/database/mongo_connector.rb', line 270

def self.tasks type=nil
  Mutx::Support::Log.debug "Getting db tasks list [type: #{type}]" if Mutx::Support::Log
  criteria = {}
  criteria["type"]=type if type
  $tasks.find(criteria).sort("last_result" => -1).to_a
end

.tasks_names_with_custom_param_id(custom_param_id) ⇒ Object 



521
522
523
524
525
 
# File 'lib/mutx/database/mongo_connector.rb', line 521

def self.tasks_names_with_custom_param_id custom_param_id
  self.tasks_with_custom_param_id(custom_param_id).map do |task|
    task["name"]
  end
end

.tasks_with_custom_param_id(custom_param_id) ⇒ Object 



527
528
529
530
531
 
# File 'lib/mutx/database/mongo_connector.rb', line 527

def self.tasks_with_custom_param_id custom_param_id
  $tasks.find({}).to_a.select do |task|
    task["custom_params"].include? custom_param_id
  end
end

.update_custom_param(custom_param_data) ⇒ Object

Update record for a given custom param $param [Hash] custom_param_data



469
470
471
472
473
 
# File 'lib/mutx/database/mongo_connector.rb', line 469

def self.update_custom_param custom_param_data
  Mutx::Support::Log.debug "Updating db custom param [#{custom_param_data}]" if Mutx::Support::Log
  id = custom_param_data["_id"]
  $custom_params.update_one( {"_id" => custom_param_data["_id"]}, custom_param_data)
end

.update_last_exec_time ⇒ Object 



333
334
335
 
# File 'lib/mutx/database/mongo_connector.rb', line 333

def self.update_last_exec_time
  $results.update_many({"cronneable" => "on"}, {"$set" => {"last_exec_time" => Time.now.utc}})
end

.update_repo_data(repo_data) ⇒ Object 



430
431
432
433
434
435
436
437
438
439
440
441
442
 
# File 'lib/mutx/database/mongo_connector.rb', line 430

def self.update_repo_data repo_data
=begin
  aux = repo_data["value"].to_json
  aux_1 = JSON.parse(aux) #=> HASH
  repo_data["value"] = JSON.parse aux_1#value en json!
=end

  aux = JSON.parse repo_data["value"].gsub('=>', ':')
  repo_data["value"] = aux
  #only update if repo exists and token is valid
  res = $repos.find({"repo_name" => repo_data["repo_name"]})
  (Mutx::Support::Log.debug "Updating repo #{repo_data["repo_name"]}" if Mutx::Support::Log
  $repos.update_one({"repo_name" => repo_data["repo_name"]}, {"$set" => {"value" => repo_data["value"], "last_update" => repo_data["last_update"]} }) ) if ( (!res.to_a.empty?) && (res.to_a[0]["repo_token"].eql? repo_data["repo_token"]) )
end

.update_result(result_data_structure) ⇒ Object

Updates result register with the given data



562
563
564
565
566
567
568
569
 
# File 'lib/mutx/database/mongo_connector.rb', line 562

def self.update_result result_data_structure
  begin
    $results.update_one( {"_id" => result_data_structure["_id"]}, result_data_structure)
    true
  rescue
    false
  end
end

.update_status(task_id, status) ⇒ Object 



372
373
374
 
# File 'lib/mutx/database/mongo_connector.rb', line 372

def self.update_status task_id, status
  $tasks.update_one({"_id" => task_id}, {"$set" => {"task_status" => status}})
end

.update_stop_bots_off(task_id) ⇒ Object

Cron_end



351
352
353
 
# File 'lib/mutx/database/mongo_connector.rb', line 351

def self.update_stop_bots_off task_id
  $tasks.update_one({"_id" => task_id}, {"$set" => {"stop_bots" => "off"}})
end

.update_stop_bots_on(task_id) ⇒ Object 



355
356
357
 
# File 'lib/mutx/database/mongo_connector.rb', line 355

def self.update_stop_bots_on task_id
  $tasks.update_one({"_id" => task_id}, {"$set" => {"stop_bots" => "on"}})
end

.update_task(task_data) ⇒ Object

Update record for a given task $param [Hash] task_data



235
236
237
238
239
240
241
242
 
# File 'lib/mutx/database/mongo_connector.rb', line 235

def self.update_task task_data
  #Fix because MD5 as _id
  #task_data["_id"] = task_data["_id"].to_i
  task_data.delete("action")
  Mutx::Support::Log.debug "Updating task [#{task_data}]" if Mutx::Support::Log
  res = $tasks.update_one( {"_id" => task_data["_id"]}, task_data)
  res.n == 1
end

.update_tasks_with_custom_param_id(custom_param_id) ⇒ Object 



388
389
390
391
392
393
 
# File 'lib/mutx/database/mongo_connector.rb', line 388

def self.update_tasks_with_custom_param_id custom_param_id
  self.tasks_with_custom_param_id(custom_param_id).each do |task_data|
    task_data["custom_params"].delete(custom_param_id)
    self.update_task task_data
  end
end

Instance Method Details

#authenticate(opts) ⇒ Object 



67
68
69
70
 
# File 'lib/mutx/database/mongo_connector.rb', line 67

def authenticate opts
  Mutx::Support::Log.debug "db authenticating" if Mutx::Support::Log
  $auth = $db.authenticate(opts[:username], opts[:pass]) if opts[:username] and opts[:pass]
end

#set_client(opts) ⇒ Object 



42
43
44
45
46
47
48
49
50
 
# File 'lib/mutx/database/mongo_connector.rb', line 42

def set_client opts
  Mutx::Support::Log.debug "Setting db client" if Mutx::Support::Log
  if !$client
    #$client = Mongo::Client.new("mongodb://#{opts[:host]}:#{opts[:port]}/#{set_db_name}")
    $client = Mongo::Client.new([ "#{opts[:host]}:#{opts[:port]}" ], :database => "#{set_db_name}")
  else
    $client
  end
end

#set_commits_collection ⇒ Object 



96
97
98
99
 
# File 'lib/mutx/database/mongo_connector.rb', line 96

def set_commits_collection
  Mutx::Support::Log.debug "Setting db commits collection" if Mutx::Support::Log
  $commits   = $db.collection("commits")
end

#set_config_collection ⇒ Object 



113
114
115
116
 
# File 'lib/mutx/database/mongo_connector.rb', line 113

def set_config_collection
  Mutx::Support::Log.debug "Setting db configuration collection" if Mutx::Support::Log
  $configuration = $db.collection("configuration")
end

#set_custom_param_collection ⇒ Object 



79
80
81
82
83
 
# File 'lib/mutx/database/mongo_connector.rb', line 79

def set_custom_param_collection
  Mutx::Support::Log.debug "Setting db custom param collection" if Mutx::Support::Log
  $custom_params  = $db.collection("custom_params")
  # $custom_params.ensure_index({"name" => 1})
end

#set_db ⇒ Object 



60
61
62
63
64
65
 
# File 'lib/mutx/database/mongo_connector.rb', line 60

def set_db
  Mutx::Support::Log.debug "Setting db" if Mutx::Support::Log
  $db = $client.database
  $client.close
  $client = nil
end

#set_db_name ⇒ Object 



36
37
38
39
40
 
# File 'lib/mutx/database/mongo_connector.rb', line 36

def set_db_name
  project_name = Dir.pwd.split("/").last
  Mutx::Support::Log.debug "Setting db name: #{project_name}_mutx" if Mutx::Support::Log
  $db_name = "#{project_name}_mutx"
end

#set_documentation_collection ⇒ Object 



108
109
110
111
 
# File 'lib/mutx/database/mongo_connector.rb', line 108

def set_documentation_collection
  Mutx::Support::Log.debug "Setting db documentation collection" if Mutx::Support::Log
  $documentation = $db.collection("documentation")
end

#set_input_collection ⇒ Object 



85
86
87
88
89
 
# File 'lib/mutx/database/mongo_connector.rb', line 85

def set_input_collection
  Mutx::Support::Log.debug "Setting db Input collection" if Mutx::Support::Log
  $inputs = $db.collection("inputs")
  $inputs.indexes.create_one({"reference" => 1})
end

#set_logger ⇒ Object 



31
32
33
34
 
# File 'lib/mutx/database/mongo_connector.rb', line 31

def set_logger
  #Mongo::Logger.logger = ::Logger.new("mutx/logs/mongo.log")
  Mongo::Logger.logger.level = ::Logger::INFO
end

#set_repos_collection ⇒ Object 



91
92
93
94
 
# File 'lib/mutx/database/mongo_connector.rb', line 91

def set_repos_collection
  Mutx::Support::Log.debug "Setting db Repos collection" if Mutx::Support::Log
  $repos = $db.collection("repos")
end

#set_results_collection ⇒ Object 



101
102
103
104
105
106
 
# File 'lib/mutx/database/mongo_connector.rb', line 101

def set_results_collection
  Mutx::Support::Log.debug "Setting db results collection" if Mutx::Support::Log
  $results   = $db.collection("results")
  # $results.ensure_index({"started_at" => 1})
  # $results.ensure_index({"_id" => 1})
end

#set_task_collection ⇒ Object 



72
73
74
75
76
77
 
# File 'lib/mutx/database/mongo_connector.rb', line 72

def set_task_collection
  Mutx::Support::Log.debug "Setting db tasks collection" if Mutx::Support::Log
  $tasks  = $db.collection("tasks")
  # $tasks.ensure_index({"name" => 1})
  # $tasks.indexes.create_one({ "name" => 1 }, :unique => true)
end