mutx 0.1.69 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 062cdb96cdcc5ace600646147f1f6669f5346db9
-  data.tar.gz: 4bea2de7bc4af28fa74849280989fb3e8451b789
+  metadata.gz: 19f6e7d0eb47b0ee32ffdb142e5dc33c86c6f7d0
+  data.tar.gz: 941938ef3a9e3dd9ea2bbf96e8aa3b786542a3e0
 SHA512:
-  metadata.gz: 96720e875c0d5c442284376ee0a79c76b190f61ee3852f139d067a837783c16d50747a9d14d37fb249019cc386f863b653dfdb134b9c98a29507021760854834
-  data.tar.gz: cfb84d8cba5a5df5ddc4070c6eafbf855731034c75426a238d1408887ddc10763537f73a4b1f4b9e814053395f6936c72ecee87b9de3c1f29d9d798bb3ea4793
+  metadata.gz: a46f7a2224a197531f00718a204fe2f295ccbfb01d8968caef7a4b3987952fa6b9c8bc0d0beeb822546a57b3238e14b7d48a95336667fb7ed48b2b23963414a9
+  data.tar.gz: 2ae2115ea7647dd42cf28bf7b0284618cb0ac5971a250b89b095e9d0556643fc6552f4affc8fde368ec3ffd629f817b205dc7dff049522b1ee023f8b79cbedd8

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    mutx (0.1.69)
+    mutx (0.2.0)
       basica
       bson_ext
       byebug
@@ -97,7 +97,7 @@ GEM
     redcarpet (3.4.0)
     redis (3.3.3)
     require_all (1.4.0)
-    rufus-scheduler (3.3.3)
+    rufus-scheduler (3.3.4)
       tzinfo
     shotgun (0.9.2)
       rack (>= 1.0)

data/documentation/repos.md

@@ -1,32 +1,29 @@
-How do i use the repositories feature?
-=====================================
+# Repositories
 
-    When we have some task or test that consume some information to run, we have the possibility on Mutx to save some info and use the API of repos to check it and use it.
+## Concept
+Repositories are units of information storage. With Repositories, you can save data to be queried later as you need.
 
-To create an info repository
-===========================
+## How to use repositories
+#### Creation
+First, a repository must be created by admin section to be used. Repo creation provide (only admin view) a unique token to be used.
+Repo token is a value to be used on putting data into a repo. Without a token, you won't be able to put data.
 
-    We only need to go to the Admin bar and click on 'Repositories'. By default we can view the list of repos. If we want to create a repo, we need to click on 'New Repo', put a name of the new repo and save it, thats it.
-
-How to save info inside a repo
-=============================
-
-    When we create a repo, we have to copy the token that the new repo has (with and invalid token or repo name Mutx will reject the request). To save info we have to make a PUT to an existing repo, for example:
-
-    PATH/api/<repo_token>/<repo_name>/
-
-    The value to save must be a JSON in the body of the request, for example: 
+Go to Admin > Repositories to configure repos
 
+#### Putting data into a repo
+To put data into a repo, you have to perform a PUT request to the mutx api url
+    
+    http://host:port/api/repos/<:token>/<:reponame>
+    
+And data has to be passed as the body in JSON format
+    
     {
-      "id": 3,
-      "name": "Visa"
+       "fav_food":"Asado",
+       "fav_drink":"Beer"
     }
 
-How to get the info of a repo
-============================
-
-    Using the API we can make a GET request to view the info of a repository, for example:
-
-    PATH/api/repos/<repo_name>
 
-    The result will be a json with the info of the repo. The values that we previously save will be in the 'values' field.
+### Getting data from a repo
+To get repository data, you have to go to the following url like:
+    
+    http://host:port/api/repos/<:reponame>

data/lib/generators/task_rack.rb

@@ -2,6 +2,7 @@
 require 'erb'
 require 'zip'
 require 'fileutils'
+require 'colorize'
 
 module Mutx
   class TaskRack < Thor::Group
@@ -22,9 +23,14 @@ module Mutx
           Mutx::Support::Logo.show
           puts "
   You have to choose one of the following branches to tell Mutx where to work with:"
-          # Print the options
+          # Print the existing branches
           branch_list.each_with_index do |branch_name, index|
-            puts "\t(#{index + 1}) - #{branch_name}"
+            line = "\t(#{index + 1}) - #{branch_name}"
+            if branch_name == "master"
+              puts line.green
+            else
+              puts line
+            end
           end
           print "\n\t     Your option:"; option = STDIN.gets
 

data/lib/generators/templates/config.ru.tt

@@ -15,5 +15,5 @@ require 'sidekiq/web'
 
 map('/sidekiq') { run Sidekiq::Web }
 
-run Cuba
+run Mutx::App
 #run Rack::URLMap.new('/' => Cuba, '/sidekiq' => Sidekiq::Web)

data/lib/mutx/API/execution.rb

@@ -25,9 +25,8 @@ module Mutx
         
         running_started = []
         running_started = Mutx::Database::MongoConnector.running_for_task task_name
-        is_there_task = Mutx::Tasks.is_there_task_with? task_name, type      
 
-        if ((is_there_task) && (running_started.empty?))
+        if Mutx::Tasks.is_there_task_with? task_name, type
           Mutx::Support::Log.debug "Starting working with task #{task_name}" if Mutx::Support::Log
 
           task = Mutx::Tasks::Task.get_task_with(task_name)
@@ -51,9 +50,7 @@ module Mutx
 
             execution_id = Mutx::Execution.run!(execution_request_data)
 
-            task.push_exec execution_id
-
-            task.save!
+            task.push_exec! execution_id
 
             Mutx::Support::Log.debug "Task #{task_name} setted as running" if Mutx::Support::Log
 
@@ -101,46 +98,13 @@ module Mutx
       # Sets as finished the result and associated task as READY
       #
       def self.reset(result_id)
-
-        Mutx::Support::Log.debug "Reset execution request for #{result_id}"
-
         result = Mutx::Results::Result.get(result_id)
-
-        task = Mutx::Tasks::Task.get(result.task_id)
-        # if is the owner
-          if result.process_running? or !result.finished? or !result.stopped?
-            begin
-              if result.pid
-                killed = true
-                Mutx::Support::Processes.kill_p(result.pid)
-                Mutx::Support::Log.debug "Execution (id=#{result.id}) killed: #{killed}"
-              end
-            rescue => e
-              Mutx::Support::Log.error "#{e}#{e.backtrace}"
-            end
-
-            begin
-              Mutx::Support::FilesCleanner.delete_report_which_has(result.id)
-              Mutx::Support::Log.debug "Execution files(id=#{result.id}) cleanned"
-              cleanned = true
-            rescue
-            end
-
-            result.save_report
-            result.reset!("forced"); 
-            Mutx::Support::Log.debug "Execution stopped!"
-            result.show_as = "pending"
-            result.save!
-
-            if killed 
-              message = "Execution: Stopped (forced) "
-              message += " Files: Cleanned" if cleanned
-            else
-              message = "Could not stop execution. Process killing: #{killed}. Files cleanned: #{cleanned}"
-              
-            end
-              
-          end
+          
+        message = if result.reset!
+          "[#{result.id}] Execution stopped"
+        else
+          "[#{result.id}] Could not stop execution"
+        end
         {"message" => message}
       end
 

data/lib/mutx/API/repo.rb

@@ -34,19 +34,16 @@ module Mutx
           end
         end
 
+        def self.all
+          Mutx::Database::MongoConnector.all_repos
+        end
+
         #GET
-				def self.get_data name, query_string=nil
-				  result = self.info name
-          if result
-            result
-          else
-            {action:"get", success:false, message:"Repo get was nok"}
-          end
+				def self.get_data id, query_string=nil
+          result = Mutx::Database::MongoConnector.repo_data_for_id(id)
+          result || { action: 'get', success: false, message: 'Repo get was nok' }
 				end
 
-				def self.info name
-				  result = Mutx::Database::MongoConnector.repo_data_for_name(name)
-				end
         #GET    
 
         def self.delete_this data

data/lib/mutx/background_jobs/workers/executor.rb

@@ -3,8 +3,7 @@ require 'mutx'
 require 'socket'
 require 'pty'
 require 'colorize'
-#require 'sidekiq/testing/inline'
-#require 'byebug'
+
 
 module Mutx
   module Workers
@@ -23,22 +22,25 @@ module Mutx
           Mutx::Support::ChangeInspector.is_there_a_change?
 
           result = Mutx::Results::Result.get(result_id)
+          puts "[#{result.id}] Execution created"
           task = Mutx::Tasks::Task.get(result.task_id)
 
           result.mutx_report_file_name= "mutx_report_#{result_id}.html"
 
           if result.is_ruby_platform?
             if Mutx::Platforms::Ruby.using_bundler?
-              bundle_output = Mutx::Support::Console.execute "bundle install"
+              bundle_output = Mutx::Support::Console.execute "bundle update"
+              puts "[#{result.id}] bundle: #{bundle_output}"
               bundle_output.slice! "fatal: Not a git repository (or any of the parent directories): .git"
             end
             if bundle_output
-              result.append_output bundle_output if bundle_output.include? "Installing"
+              result.append_output! bundle_output if bundle_output.include? "Installing"
               if bundle_output.include? "Could not find"
+                puts "[#{result.id}] Finished because of Could not find gem"
                 result.finish!
                 raise "An error ocurred installing gem while executing bundler"
               else
-                result.append_output "All GEMS are installed and running!\nEXECUTION OUTPUT:\n\n--"                
+                result.append_output! "All GEMS are installed and running!\nEXECUTION OUTPUT:\n\n--"                
               end
             end
           end
@@ -51,69 +53,71 @@ module Mutx
           efective_command << "-f pretty -f html -o mutx/temp/#{result.mutx_report_file_name}" if result.is_cucumber?
           efective_command << result.custom_params_values
           efective_command << "_id=#{result.id}" # to use inside execution the possibility to add information to the result
-
+          puts "[#{result.id}] Command: #{efective_command.join(" ")}"
           result.mutx_command= efective_command.join(" ")
 
           attach_folder = "#{Dir.pwd}/mutx/out/#{result.id}/attachment"
 
-          # To Be Deleted on prod
-          Mutx::Support::Log.debug "[result:#{result.id}] #{efective_command.join(' ')}" if Mutx::Support::Log
-
           result.running!
-
-          Mutx::Support::Log.debug "[result:#{result.id}] setted as running" if Mutx::Support::Log
+          puts "[#{result.id}] setted as running"
 
           @output = ""
 
-          #################
-          # POPEN3 ref
-          # http://blog.honeybadger.io/capturing-stdout-stderr-from-shell-commands-via-ruby/?utm_source=rubyweekly&utm_medium=email
-          ##################
           @count = 0
 
-          # Update repo if changes are found
-          ##if Mutx::Support::Configuration.use_git?
-          ##  Mutx::Support::Git.pull unless Mutx::Support::Git.up_to_date?
-          ##end # PULL COMMENTED
-
           if !Mutx::Support::Configuration.proxys.empty?
             Mutx::Support::Configuration.proxys.detect{|proxy| Mutx::Support::Console.execute proxy}
           end
 
           Mutx::Support::TimeHelper.start # Sets timestamp before start process
-          Mutx::Support::Log.debug "[result:#{result.id}] Creating process" if Mutx::Support::Log
 
-          #USE 'PTY' GEM INSTEAD POPEN TO READ OUTPUT IN REAL TIME
           @start_time = Time.now
           begin
+           
+
+
             PTY.spawn("#{result.mutx_command}") do |stdout, stdin, pid|
-              result.pid ="#{`ps -fea | grep #{Process.pid} | grep -v grep | awk '$2!=#{Process.pid} && $8!~/awk/ && $3==#{Process.pid}{print $2}'`}"
-              result.save!
               begin
+                if result.pid.nil?
+                  puts "[#{result.id}] pid #{pid}"
+                  result.pid = pid
+                  result.save!
+                end
                 stdout.each { |line|
-                  @output += line
+                  @output = line
                   @output.slice! "fatal: Not a git repository (or any of the parent directories): .git"
-                  #if Mutx::Support::TimeHelper.elapsed_from_last_check_greater_than? 5
-                    result.append_output @output.gsub(/(\[\d{1,2}\m)/, "")
-                    @output = ""
-                  #end
-                  if result.seconds_without_changes > Mutx::Support::Configuration.execution_time_to_live
+                  result.append_output! @output.gsub(/(\[\d{1,2}\m)/, "")
+
+                  if result.time_to_live_reached?
                     result.finished_by_timeout! and break
                   end
                 }
-                result.append_output @output unless @output.empty?
-                result.append_output "=========================\n"
+                result.append_output! @output unless @output.empty?                
               rescue Errno::EIO, Errno::ENOENT => e
+                puts "[#{result_id}] Errno::EIO, Errno::ENOENT => e"
+              rescue PTY::ChildExited, Errno::ENOENT => e
+                cmd = result.mutx_command.match(/(\D*)\_/)[0].delete"_"
+                exception_message = "EXCEPTION: #{e.message} for the command requested for you: #{cmd.upcase}"
+                puts "[#{result.id}] exception_message: #{exception_message}"
+                @output = exception_message
+                result.append_output! @output unless @output.empty?
+              rescue => e
+                puts "[#{result_id}] Unknown exception"
               end
+
             end
-          rescue PTY::ChildExited, Errno::ENOENT => e
-            cmd = result.mutx_command.match(/(\D*)\_/)[0].delete"_"
-            @output = "EXCEPTION: #{e.message} for the command requested for you: #{cmd.upcase}"
-            result.append_output @output unless @output.empty?
-            result.append_output "\n\n=========================\n"
+  
+          rescue => e
+            puts "#######################}WTF #{e} #{e.backtrace}"
+            # result.reset!
+            puts "[#{result.id}] Reseted"
           end
 
+          result = Mutx::Results::Result.get(result_id)
+          puts "[#{result.id}] Status before ensure finish => #{result.status}"
           result.ensure_finished!
+          result.eval_regex!
+          puts "[#{result.id}] ensure finished"
 
           puts result.summary
 
@@ -130,6 +134,8 @@ module Mutx
           id = task[:_id]
           cucumber = task[:cucumber]
           notify_on = task[:notify_on]
+
+          result.eval_regex!
           
           if ( (task["notifications"].eql? "on") && (!task["stop_bots"].eql? "on") && (!task["stop_bots"].eql? "off") && (!result.regex.empty?) && (result.console_output.to_s.include? "#{result.regex.to_s}") )
             Mutx::Database::MongoConnector.mark_notified (result_id)
@@ -149,7 +155,7 @@ module Mutx
             puts "****Result not to being notified, because regex #{result.regex.to_s} not included on output****"          
           end
 
-          Mutx::Support::Log.debug "[result:#{result.id}]| command => #{result.mutx_command} | result as => #{result.status}" if Mutx::Support::Log
+          puts "[result:#{result.id}]| command => #{result.mutx_command} | result as => #{result.status}"
           
           Mutx::Database::MongoConnector.force_close
         end

data/lib/mutx/commands/install.rb

@@ -18,7 +18,7 @@ module Mutx
         puts "Now, you can run bundle install and then `mutx start` command"
 
       rescue => e
-        puts "\n\nERROR: #{e}\n\n #{e.backtrace}"
+        puts "\n\nInstallation Error: #{e}\n\n".red
 
       end
     end

data/lib/mutx/commands/start.rb

@@ -7,7 +7,7 @@ module Mutx
         pids = (Mutx::Support::Processes.sidekiq_pids).concat(Mutx::Support::Processes.mutx_pids)
         
         if pids.size > 0
-            puts "It seems that MuTX is already running"
+            puts "It seems that MuTX is already running. pids found [#{pids}]"
             puts "Please, run `mutx stop` command before starting MuTX"
         else
           Mutx::Support::Log.start

data/lib/mutx/custom/execution.rb

@@ -28,7 +28,7 @@ module Mutx
         if self.is_there_result?
           result = self.get_result
           if result and result.running?
-            result.add_execution_data key, value if key
+            result.add_execution_data! key, value if key
             {key => value}
           end
         end

data/lib/mutx/database/mongo_connector.rb

@@ -39,16 +39,6 @@ module Mutx
         $db_name = "#{project_name}_mutx"
       end
 
-      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
-
       def self.force_close
         $client.close if $client
       end
@@ -57,13 +47,6 @@ module Mutx
         MongoConnection.instance.close
       end
 
-      def set_db
-        Mutx::Support::Log.debug "Setting db" if Mutx::Support::Log
-        $db = $client.database
-        $client.close
-        $client = nil
-      end
-
       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]
@@ -72,14 +55,12 @@ module Mutx
       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)
+        $tasks.indexes.create_one({ "name" => 1 }, :unique => true)
       end
 
       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
 
       def set_input_collection
@@ -101,8 +82,10 @@ module Mutx
       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})
+        $results.indexes.create_many([
+          { :key => { "_id" => 1 }, unique: true },
+          { :key => { "started_at": -1 } }
+        ])
       end
 
       def set_documentation_collection
@@ -447,6 +430,12 @@ module Mutx
       res
     end
 
+    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
+
 
     ########################################
     # CUSTOM PARAMS
@@ -620,6 +609,14 @@ module Mutx
         $results.find({$or => [{"summary" => /#{status}/}, {"status" => /#{status}/ }]},{"_id" => 1}).to_a
       end
 
+      def self.status_for_result result_id
+        begin
+          $results.find({"_id" => result_id}).to_a.first["status"]
+        rescue
+          nil
+        end
+      end
+
     ######################################3
     # CONFIG
     #