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 



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

def self.active_tasks
  self.all_tasks
end

.all_repos ⇒ Object

REPOS



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

def self.all_repos
  res = $repos.find({}).sort({"repo_name" => 1})
  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



269
270
271
 
# File 'lib/mutx/database/mongo_connector.rb', line 269

def self.all_tasks
  self.tasks
end

.all_tests ⇒ Object 



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

def self.all_tests
  self.tasks "test"
end

.clean_documentation ⇒ Object

Removes all documents of documentation from the DB



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

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 



46
47
48
 
# File 'lib/mutx/database/mongo_connector.rb', line 46

def self.close
  MongoConnection.instance.close
end

.collections ⇒ Object

Returns a list of collections



169
170
171
 
# File 'lib/mutx/database/mongo_connector.rb', line 169

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

.configuration ⇒ Object 



640
641
642
643
 
# File 'lib/mutx/database/mongo_connector.rb', line 640

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) 


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

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

.cron_tasks ⇒ Object

Get cronneable tasks



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

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_repo(repo_id) ⇒ Object 



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

def self.delete_repo repo_id
  Mutx::Support::Log.debug "REPO BORRADO" if Mutx::Support::Log
  res = $repos.delete_one({"_id" => repo_id})
  res.n==1
end

.delete_started_result(result_id) ⇒ Object 



325
326
327
328
329
330
331
 
# File 'lib/mutx/database/mongo_connector.rb', line 325

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 



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

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 



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

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 



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

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 



42
43
44
 
# File 'lib/mutx/database/mongo_connector.rb', line 42

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

.generate_id ⇒ Object 



158
159
160
161
 
# File 'lib/mutx/database/mongo_connector.rb', line 158

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 



163
164
165
166
 
# File 'lib/mutx/database/mongo_connector.rb', line 163

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



119
120
121
122
 
# File 'lib/mutx/database/mongo_connector.rb', line 119

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



125
126
127
128
129
 
# File 'lib/mutx/database/mongo_connector.rb', line 125

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



139
140
141
142
 
# File 'lib/mutx/database/mongo_connector.rb', line 139

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



132
133
134
135
136
 
# File 'lib/mutx/database/mongo_connector.rb', line 132

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 



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

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



191
192
193
 
# File 'lib/mutx/database/mongo_connector.rb', line 191

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

.insert_config(config_object) ⇒ Object

3 CONFIG



635
636
637
638
 
# File 'lib/mutx/database/mongo_connector.rb', line 635

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



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

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 



385
386
387
388
 
# File 'lib/mutx/database/mongo_connector.rb', line 385

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 



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

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)



211
212
213
214
 
# File 'lib/mutx/database/mongo_connector.rb', line 211

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



197
198
199
200
201
202
203
 
# File 'lib/mutx/database/mongo_connector.rb', line 197

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



346
347
348
349
 
# File 'lib/mutx/database/mongo_connector.rb', line 346

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 



342
343
344
 
# File 'lib/mutx/database/mongo_connector.rb', line 342

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

.only_running_for_task(task_name) ⇒ Object 



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

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 



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

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_id(id) ⇒ Object 



438
439
440
441
442
 
# File 'lib/mutx/database/mongo_connector.rb', line 438

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

.repo_data_for_name(name) ⇒ Object 



432
433
434
435
436
 
# File 'lib/mutx/database/mongo_connector.rb', line 432

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 



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

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



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

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 



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

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 



277
278
279
 
# File 'lib/mutx/database/mongo_connector.rb', line 277

def self.running_tasks
  self.running "task"
end

.running_tests ⇒ Object 



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

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



312
313
314
 
# File 'lib/mutx/database/mongo_connector.rb', line 312

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

.status_for_result(result_id) ⇒ Object 



623
624
625
626
627
628
629
 
# File 'lib/mutx/database/mongo_connector.rb', line 623

def self.status_for_result result_id
  begin
    $results.find({"_id" => result_id}).to_a.first["status"]
  rescue
    nil
  end
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



230
231
232
233
234
235
 
# File 'lib/mutx/database/mongo_connector.rb', line 230

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 



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

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



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

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 



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

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 



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

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 



413
414
415
416
417
418
419
420
421
422
423
424
425
 
# File 'lib/mutx/database/mongo_connector.rb', line 413

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_repo_name(id, name) ⇒ Object 



427
428
429
430
 
# File 'lib/mutx/database/mongo_connector.rb', line 427

def self.update_repo_name id, name
  res = $repos.find({"_id" => id})
  ($repos.update_one({"_id" => id}, {"$set" => {"repo_name" => name} }) ) if !res.to_a.empty?
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 



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

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



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

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 



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

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



218
219
220
221
222
223
224
225
 
# File 'lib/mutx/database/mongo_connector.rb', line 218

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 



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

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 



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

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_commits_collection ⇒ Object 



77
78
79
80
 
# File 'lib/mutx/database/mongo_connector.rb', line 77

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 



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

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 



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

def set_custom_param_collection
  Mutx::Support::Log.debug "Setting db custom param collection" if Mutx::Support::Log
  $custom_params  = $db.collection("custom_params")
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 



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

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 



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

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 



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

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 



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

def set_results_collection
  Mutx::Support::Log.debug "Setting db results collection" if Mutx::Support::Log
  $results   = $db.collection("results")
  $results.indexes.create_many([
    { :key => { "_id" => 1 }, unique: true },
    { :key => { "started_at": -1 } }
  ])
end

#set_task_collection ⇒ Object 



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

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