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



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

def initialize(opts={host: "localhost", port: 27017, username: nil, pass: nil})
  set_client(opts)
  set_db
  authenticate(opts)
  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 



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

def self.active_tasks
  self.all_tasks
end

.all_repos ⇒ Object

REPOS



405
406
407
408
409
 
# File 'lib/mutx/database/mongo_connector.rb', line 405

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



585
586
587
 
# File 'lib/mutx/database/mongo_connector.rb', line 585

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

.all_results_ids ⇒ Object 



589
590
591
 
# File 'lib/mutx/database/mongo_connector.rb', line 589

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

.all_tasks ⇒ Object

Returns all active tasks



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

def self.all_tasks
  self.tasks
end

.all_tests ⇒ Object 



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

def self.all_tests
  self.tasks "test"
end

.clean_documentation ⇒ Object

Removes all documents of documentation from the DB



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

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

.collections ⇒ Object

Returns a list of collections



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

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

.configuration ⇒ Object 



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

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) 


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

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

.cron_tasks ⇒ Object

Get cronneable tasks



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

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 



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

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



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

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 



491
492
493
494
495
496
 
# File 'lib/mutx/database/mongo_connector.rb', line 491

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 



333
334
335
336
337
338
339
 
# File 'lib/mutx/database/mongo_connector.rb', line 333

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 



367
368
369
370
371
372
373
 
# File 'lib/mutx/database/mongo_connector.rb', line 367

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 



181
182
183
184
185
186
187
 
# File 'lib/mutx/database/mongo_connector.rb', line 181

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]



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

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) 


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

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) 


482
483
484
 
# File 'lib/mutx/database/mongo_connector.rb', line 482

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) 


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

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 



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

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

.find_results_for_key(key) ⇒ Object 



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

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 



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

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 



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

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 



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

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

.generate_id ⇒ Object 



166
167
168
169
 
# File 'lib/mutx/database/mongo_connector.rb', line 166

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 



171
172
173
174
 
# File 'lib/mutx/database/mongo_connector.rb', line 171

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



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

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



465
466
467
468
469
 
# File 'lib/mutx/database/mongo_connector.rb', line 465

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



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

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



147
148
149
150
 
# File 'lib/mutx/database/mongo_connector.rb', line 147

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



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

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 



394
395
396
397
398
 
# File 'lib/mutx/database/mongo_connector.rb', line 394

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



199
200
201
 
# File 'lib/mutx/database/mongo_connector.rb', line 199

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

.insert_config(config_object) ⇒ Object

3 CONFIG



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

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 



449
450
451
452
 
# File 'lib/mutx/database/mongo_connector.rb', line 449

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



121
122
123
124
 
# File 'lib/mutx/database/mongo_connector.rb', line 121

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 



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

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 



411
412
413
414
415
 
# File 'lib/mutx/database/mongo_connector.rb', line 411

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



530
531
532
533
534
535
536
537
 
# File 'lib/mutx/database/mongo_connector.rb', line 530

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)



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

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



205
206
207
208
209
210
211
 
# File 'lib/mutx/database/mongo_connector.rb', line 205

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



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

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 



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

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

.mark_notified(result_id) ⇒ Object 



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

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

.only_running_for_task(task_name) ⇒ Object 



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

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 



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

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 



471
472
473
474
475
 
# File 'lib/mutx/database/mongo_connector.rb', line 471

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 



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

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 



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

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

.result_data_for_id(result_id) ⇒ Object 



558
559
560
561
562
563
564
 
# File 'lib/mutx/database/mongo_connector.rb', line 558

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



540
541
542
543
544
545
 
# File 'lib/mutx/database/mongo_connector.rb', line 540

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 



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

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



306
307
308
309
 
# File 'lib/mutx/database/mongo_connector.rb', line 306

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 



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

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 



570
571
572
 
# File 'lib/mutx/database/mongo_connector.rb', line 570

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

.running_results_for_task_id(task_id) ⇒ Object 



566
567
568
 
# File 'lib/mutx/database/mongo_connector.rb', line 566

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 



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

def self.running_tasks
  self.running "task"
end

.running_tests ⇒ Object 



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

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



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

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



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

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 



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

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



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

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 



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

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 



508
509
510
511
512
 
# File 'lib/mutx/database/mongo_connector.rb', line 508

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 



514
515
516
517
518
 
# File 'lib/mutx/database/mongo_connector.rb', line 514

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



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

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 



324
325
326
 
# File 'lib/mutx/database/mongo_connector.rb', line 324

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 



417
418
419
420
421
422
423
424
425
426
427
428
429
 
# File 'lib/mutx/database/mongo_connector.rb', line 417

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



549
550
551
552
553
554
555
556
 
# File 'lib/mutx/database/mongo_connector.rb', line 549

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_stop_bots_off(task_id) ⇒ Object

Cron_end



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

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 



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

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



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

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 



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

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 



58
59
60
61
 
# File 'lib/mutx/database/mongo_connector.rb', line 58

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 



37
38
39
40
41
42
43
44
45
 
# File 'lib/mutx/database/mongo_connector.rb', line 37

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 



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

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 



104
105
106
107
 
# File 'lib/mutx/database/mongo_connector.rb', line 104

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 



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

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 



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

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 



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

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 



99
100
101
102
 
# File 'lib/mutx/database/mongo_connector.rb', line 99

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 



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

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 



26
27
28
29
 
# File 'lib/mutx/database/mongo_connector.rb', line 26

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

#set_repos_collection ⇒ Object 



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

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 



92
93
94
95
96
97
 
# File 'lib/mutx/database/mongo_connector.rb', line 92

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 



63
64
65
66
67
68
 
# File 'lib/mutx/database/mongo_connector.rb', line 63

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