mu 5.7.2.3

data/lib/mu/command/curl.rb

@@ -0,0 +1,246 @@
+class Mu
+class Command
+class Curl < Command
+    def cmd_help argv
+        help
+    end
+
+    def authorize_error e
+        base_url = "#{e.scheme}://#{e.host}:#{e.port}"
+        puts
+        error "You haven't verified that you are the dev/ops for #{e.host}"
+        puts
+    end
+
+    def cmd_run argv
+        args = parse_cli argv
+        if args['help']
+            return help
+        end
+
+        if not args['pattern']
+            verify args
+            return
+        end
+    end
+    
+    alias_method :cmd_default, :cmd_run
+
+    private
+    def verify args
+        begin
+            job = ::Mu::Curl::Verify.execute args
+            result = job.result
+            print_verify_result args, result
+        rescue ::Mu::Curl::Error::Authorize => e
+            authorize_error e
+        rescue ::Mu::Curl::Error::Region => e
+            error "#{e.region}: #{e.message}"
+        rescue ::Mu::Curl::Error => e
+            error e.message
+        end
+    end
+
+    def print_verify_result args, result
+        rtt = result.duration
+		if rtt < 1.0
+			rtt = (rtt * 1000).floor.to_s + ' ms';
+		else
+			rtt = ("%.2f" % rtt) + ' sec';
+		end
+
+		puts "-" * 70
+        msg "#{result.region}: Response time of #{rtt}"
+        puts "-" * 70
+        puts
+
+        if args['dump-header'] || args['verbose']
+            puts "> " + result.request.line
+            result.request.headers.each_pair { |k, v| puts "> #{k}: #{v}\r\n" }
+            puts
+        
+            content = result.request.content
+            if not content.empty?
+                if /^[[:print:]]+$/ =~ content
+                    puts content
+                else
+                    puts Hexy.new(content).to_s
+                end
+                puts
+            end
+        
+            puts "< " + result.response.line
+            result.response.headers.each_pair { |k, v| puts "> #{k}: #{v}\r\n" }
+            puts
+        end
+        
+        content = result.response.content
+        if not content.empty?
+            if /^[[:print:]]+$/ =~ content
+                puts content
+            else
+                puts Hexy.new(content).to_s
+            end
+        end
+    end
+
+    def help
+        helps = [
+            { :short => '-A', :long => '--user-agent', :value => '<string>', :help => 'User-Agent to send to server' },
+            { :short => '-b', :long => '--cookie', :value => 'name=<string>', :help => 'Cookie to send to the server (multiple)' },
+            { :short => '-d', :long => '--data', :value => '<string>', :help => 'Data to send in a PUT or POST request' },
+            { :short => '-D', :long => '--dump-header', :value => '<file>', :help => 'Print the request/response headers' },
+            { :short => '-e', :long => '--referer', :value => '<string>', :help => 'Referer URL' },
+            { :short => '-h', :long => '--help', :value => '', :help => 'Help on command line options' },
+            { :short => '-H', :long => '--header', :value => '<string>', :help => 'Custom header to pass to server' },
+            { :short => '-p', :long => '--pattern', :value => '<s>-<e>:<d>', :help => 'Ramp from s to e concurrent requests in d secs' },
+            { :short => '-r', :long => '--region', :value => '<string>', :help => 'Choose one of us-east or us-west' },
+            { :short => '-s', :long => '--status', :value => '<number>', :help => 'Assert on the HTTP response status code' },
+            { :short => '-T', :long => '--timeout', :value => '<ms>', :help => 'Wait time for both connect and responses' },
+            { :short => '-u', :long => '--user', :value => '<user[:pass]>', :help => 'User and password for authentication' },
+            { :short => '-X', :long => '--request', :value => '<string>', :help => 'Request method to use (GET, HEAD, PUT, etc.)' },
+            { :short => '-v', :long => '--verbose', :value => '', :help => 'Print the request/response headers' },
+            { :short => '-1', :long => '--tlsv1', :value => '', :help => 'Use TLSv1 (SSL)' },
+            { :short => '-2', :long => '--sslv2', :value => '', :help => 'Use SSLv2 (SSL)' },
+            { :short => '-3', :long => '--sslv3', :value => '', :help => 'Use SSLv3 (SSL)' }
+        ]
+
+        max_long_size = helps.inject(0) { |memo, obj| [ obj[:long].size, memo ].max }
+        max_value_size = helps.inject(0) { |memo, obj| [ obj[:value].size, memo ].max }
+        puts
+        msg "Usage: mu curl <options> <url>"
+        puts
+        helps.each do |h|
+            msg "%-*s %*s %-*s %s" % [max_long_size, h[:long], 2, h[:short], max_value_size, h[:value], h[:help]]
+        end
+        puts
+    end
+
+    def parse_cli argv
+        hash = Hash.new
+        while not argv.empty?
+            break if argv.first[0,1] != '-'
+
+            k = argv.shift
+            if [ '-A', '--user-agent' ].member? k
+                hash['user-agent'] = shift(k, argv)
+                next
+            end
+
+            if [ '-b', '--cookie' ].member? k
+                # TODO: support cookie jars
+                hash['cookies'] ||= []
+                hash['cookies'] << shift(k, argv)
+                next
+            end
+
+            if [ '-d', '--data' ].member? k
+                # TODO: Read from a file using the @syntax
+                hash['content'] ||= Hash.new
+                hash['content']['data'] ||= []
+                hash['content']['data'] << shift(k, argv)
+                next
+            end
+
+            if [ '-D', '--dump-header' ].member? k
+                hash['dump-header'] = shift(k, argv)
+                next
+            end
+
+            if [ '-e', '--referer'].member? k
+                hash['referer'] = shift(k, argv)
+                next
+            end
+
+            if [ '-h', '--help' ].member? k
+                hash['help'] = true
+                next
+            end
+
+            if [ '-H', '--header' ].member? k
+                hash['headers'] ||= []
+                hash['headers'].push shift(k, argv)
+                next
+            end
+
+            if [ '-p', '--pattern' ].member? k
+                v = shift(k, argv)
+                if not /^(\d+)-(\d+):(\d+)$/ =~ v
+                    raise "invalid ramp pattern"
+                end
+                hash['pattern'] = {
+                    'iterations' => 1,
+                    'intervals' => [{
+                        'iterations' => 1,
+                        'start' => $1.to_i,
+                        'end' => $2.to_i,
+                        'duration' => $3.to_i
+                    }]
+                }
+                next
+            end
+
+            if [ '-r', '--region' ].member? k
+                v = shift(k, argv)
+                if !v.include?("us-west") and !v.include?("us-east")
+                  raise 'region must be one of us-west or us-east'
+                end
+                hash['region'] = v
+                next
+            end
+
+            if [ '-s', '--status' ].member? k
+                hash['status'] = shift(k, argv).to_i
+                next
+            end
+
+            if [ '-T', '--timeout' ].member? k
+                hash['timeout'] = shift(k, argv).to_i
+                next
+            end
+
+            if [ '-u', '--user' ].member? k
+                hash['user'] = shift(k, argv)
+                next
+            end
+
+            if [ '-X', '--request' ].member? k
+                hash['request'] = shift(k, argv)
+                next
+            end
+            
+            if [ '-v', '--verbose' ].member? k
+                hash['verbose'] = true
+                next
+            end
+
+            if [ '-1', '--tlsv1' ].member? k
+                hash['ssl'] = 'tlsv1'
+                next
+            end
+
+            if [ '-2', '--sslv2' ].member? k
+                hash['ssl'] = 'sslv2'
+                next
+            end
+
+            if [ '-3', '--sslv3' ].member? k
+                hash['ssl'] = 'sslv2'
+                next
+            end
+
+            raise ArgumentError, "Unknown option #{k}"
+        end
+
+        if not hash['help']
+            url = argv.shift
+            raise 'no URL specified!' if url.nil?
+            hash['url'] = url
+        end
+
+        hash
+    end
+
+end # Curl
+end # Command
+end # Mu

data/lib/mu/command/help.rb

@@ -0,0 +1,29 @@
+class Mu
+class Command
+class Help < Command
+    def cmd_default argv
+        puts
+        puts "Usage: mu <command>:<option>"
+        helps = [
+            { :cmd => 'mu help', :help => "Display this help" },
+            { :cmd => 'mu cmd_appid:help', :help => 'Show help on using the appid application for running multi-host msl files at scale'},
+            { :cmd => 'mu cmd_cli:help', :help => 'Show help on using the Mu CLI Api through the command-line' },
+            { :cmd => 'mu cmd_ddt:help', :help => 'Show help on using the Studio Verify Api through the command-line' },
+            { :cmd => 'mu cmd_homepage:help', :help => 'Show help on using the Homepage Api through the command-line' },
+            { :cmd => 'mu cmd_muapi:help', :help => 'Show help on using the Mu Api for fuzzing, templates, backup and archive' },
+            { :cmd => 'mu cmd_netconfig:help', :help => 'Show help on using the Netconfig Api through the command-line'},
+            { :cmd => 'mu cmd_runscale:help', :help => 'Show help on running the Studio Scale app'},
+            { :cmd => 'mu cmd_runscenario:help', :help => 'Show help on running the Scenario Editor Verify app' },
+            { :cmd => 'mu cmd_runverify:help', :help => 'Show help on running the Studio Verify app' },
+            { :cmd => 'mu cmd_scale:help', :help => 'Show help on using the Scale Api through the command-line' },
+            { :cmd => 'mu cmd_system:help', :help => 'Show help on using the System Api through the command-line' },
+        ]
+        max_cmd_size = helps.inject(0) { |memo, obj| [ obj[:cmd].size, memo ].max } + 4
+        helps.each do |h|
+            puts "%*s - %s" % [max_cmd_size, h[:cmd], h[:help]]
+        end
+        puts
+    end
+end
+end # Command
+end # Mu

data/lib/mu/curl/error.rb

@@ -0,0 +1,54 @@
+class Mu
+module Curl
+class Error < StandardError
+    def initialize json={}
+        super json['reason'] || "Hmmm, something went wrong. Try again in a little bit?"
+    end
+    
+    class Authorize < Error
+        attr_reader :scheme, :host, :port, :uuid
+
+        def initialize json
+            @scheme = json['scheme']
+            @host   = json['host']
+            @port   = json['port']
+            @uuid   = json['uuid']
+            super
+        end
+    end
+    
+    class Region < Error
+        attr_reader :region
+        
+        def initialize json
+            @region = json['region']
+            super
+        end
+    end
+    
+    class DNS < Region
+    end
+    
+    class Connect < Region
+        def initialize json
+            json['reason'] = "Can't connect to this server"
+            super
+        end
+    end
+    
+    class Timeout < Region
+        def initialize json
+            json['reason'] = "Response timed out. Try increasing --timeout"
+            super
+        end
+    end
+    
+    class Status < Region
+        def initialize json
+            json['reason'] = "Assertion on status failed"
+            super
+        end
+    end
+end
+end # Curl
+end # Mu

data/lib/mu/curl/verify.rb

@@ -0,0 +1,137 @@
+class Mu
+module Curl 
+class Verify
+    class Request
+        def self.parse data
+            ios = StringIO.new data.unpack('m')[0]
+            rqrs = { :line => '', :headers => [], :content => '' }
+            while true
+                line = ios.readline
+                break if not line or line == "\r\n"
+                if rqrs[:line].empty?
+                    rqrs[:line] = line.chomp
+                else
+                    if /^([^:]+):(.*)/ =~ line
+                        key = $1
+                        val = $2.strip
+                        rqrs[:headers] << { :line => line.chomp, :key => key, :val => val }
+                    end
+                end
+            end
+
+            rqrs[:content] = ios.read
+            return rqrs
+        end
+        
+        attr_reader :line
+        attr_reader :method
+        attr_reader :url
+        attr_reader :headers
+        attr_reader :content
+        
+        def initialize json
+            rq = Request.parse json['bytes'][0]['data']
+            @line = rq[:line]
+            @method, @url, _ = rq[:line].split(/\s+/, 3)
+            @content = rq[:content]
+            @headers = Hash.new
+            rq[:headers].each { |h| @headers[h[:key]] = h[:val] }
+        end
+    end
+    
+    class Response
+        attr_reader :line
+        attr_reader :status
+        attr_reader :message
+        attr_reader :headers
+        attr_reader :content
+        
+        def initialize json
+            rs = Request.parse json['bytes'][1]['data']
+            @line = rs[:line]
+            _, @status, @message = rs[:line].split(/\s+/, 3)
+            @status = @status.to_i
+            @content = rs[:content]
+            @headers = Hash.new
+            rs[:headers].each { |h| @headers[h[:key]] = h[:val] }
+        end        
+    end
+    
+    class Result
+        attr_reader :region
+        attr_reader :duration
+        attr_reader :connect
+        attr_reader :request
+        attr_reader :response
+        
+        def initialize json
+            result = json['result']
+            stats = result['statistics']
+            
+            @region = json['region']
+            @duration = stats['duration']['avg']
+            @connect = stats['steps'][0]['duration']['avg']
+            @request = Request.new result
+            @response = Response.new result
+        end        
+    end
+    
+    def self.execute args
+        args.delete 'pattern'
+
+        res = Command::API.client.curl args
+        if res['error']
+            if res['error'] == 'authorize'
+                raise Error::Authorize.new(res)
+            else
+                raise Error.new(res)
+            end
+        end
+
+        return self.new(res['job_id'])
+    end
+    
+    attr_reader :job_id
+    
+    def initialize job_id
+        @job_id = job_id
+    end
+    
+    def result
+        while true
+            sleep 2.0
+
+            job = Command::API.client.job_status job_id
+            if job['error']
+                raise Error
+            end
+
+            result = job['result']
+            next if job['status'] == 'queued'
+            next if job['status'] == 'running' and not result
+
+            if result['error']
+                result['region'] = job['region']
+                if result['dns']
+                    raise Error::DNS.new(result)
+                elsif result['step'] == 0
+                    raise Error::Connect.new(result)
+                elsif result['step'] == 2
+                    raise Error::Timeout.new(result)
+                elsif result['assert'] == 0
+                    raise Error::Status.new(result)
+                else
+                    raise Error
+                end
+            end
+            
+            return Result.new(job)
+        end
+    end
+    
+    def abort
+        Command::API.client.abort_job job_id rescue nil
+    end    
+end
+end # Curl
+end # Mu