Altentee » Performance & Test Automation Experts » network http://altentee.com Performance and Test Automation Experts Sat, 12 Jun 2010 00:35:08 +0000 http://wordpress.org/?v=2.9 en hourly 1 Determining Network Time in Watir Scripts http://altentee.com/2009/determining-network-time-in-watir-scripts/ http://altentee.com/2009/determining-network-time-in-watir-scripts/#comments Thu, 26 Mar 2009 01:35:08 +0000 Tim Koopmans http://90kts.com/blog/2009/determining-network-time-in-watir-scripts/ By this I mean I wanted to determine how much network and server time was spent processing a request initiated by a Watir script. Server time as defined by time to first buffer and network time as time to last buffer (minus the first).

I couldn’t really do this from Ruby itself, so I installed Fiddler. [...]]]> By this I mean I wanted to determine how much network and server time was spent processing a request initiated by a Watir script. Server time as defined by time to first buffer and network time as time to last buffer (minus the first).

I couldn’t really do this from Ruby itself, so I installed Fiddler. Fiddler lets you capture traffic in much the same way as ethereal / wireshark but with a nice GUI. There are some Fiddler customization scripts which let you display this info in the Custom column i.e.
oSession["ui-customcolumn"] = "FB: " + oSession["X-TTFB"] + "; LB: " + oSession["X-TTLB"];

But if you’re a neat freak like me and want them in separate columns then do this:

public static BindUIColumn("Time")
function CalcMethodCol1(oS: Session){
if (null != oS.oRequest) return DateTime.Now.ToString("dd/MM/yy HH:mm:ss.ffff");
else return String.Empty;
}

public static BindUIColumn("AbbreviatedUrl")
function CalcMethodCol2(oS: Session){
if (null != oS.oRequest) return oS.url.substring(oS.url.lastIndexOf("/"));
else return String.Empty;
}

public static BindUIColumn("TTFBuffer")
function CalcMethodCol3(oS: Session){
if (null != oS.oResponse) return oS["X-TTFB"];
else return String.Empty;
}

public static BindUIColumn("TTLBuffer")
function CalcMethodCol4(oS: Session){
if (null != oS.oResponse) return oS["X-TTLB"];
else return String.Empty;
}

You place them before you declare the static function OnBeforeRequest. The time stamp used above ends up being the ‘end’ timestamp, not the ’start’ so you just need to subtract time to last buffer to determine that. You end up with this in your summary view:
ttfb.png

Once this is done you can pretty up the results by copying the ‘Full Summary’ for your selected sessions in Fiddler and pasting them into Excel. This was the main reason for doing this. If you’re happy with the Fiddler ‘timeline’ view then you don’t need to bother. I just wanted the data so I could merge/correlate with other data sources.
gantt.png

Would be interested to know if anyone has achieved this in ruby itself. I was thinking of using the webrick/httpproxy but would have come short if testing a HTTPS web app.

]]> http://altentee.com/2009/determining-network-time-in-watir-scripts/feed/ 0 Faking it! (UDP packets that is…) http://altentee.com/2007/faking-it-udp-packets-that-is/ http://altentee.com/2007/faking-it-udp-packets-that-is/#comments Wed, 02 May 2007 22:51:51 +0000 Tim Koopmans http://90kts.com/blog/2007/faking-it-udp-packets-that-is/ An associate of mine recently wanted a load script that could simulate thousands of UDP packets carrying a custom payload coming from different IP addresses. They were implementing a customised RFID solution that needed to simulate load from a lot of sources (think active RFID tags).

There are many different ways you can accomplish this, solutions [...]]]> An associate of mine recently wanted a load script that could simulate thousands of UDP packets carrying a custom payload coming from different IP addresses. They were implementing a customised RFID solution that needed to simulate load from a lot of sources (think active RFID tags).

There are many different ways you can accomplish this, solutions like LoadRunner will offer the ability to spoof source IP addresses, but in this case the client couldn’t afford hefty licensing fees. So getting back to basics, I launched the *flood* from a cygwin shell running ruby.

The code looked a little like this…


UDP Faker.rb

def ipchecksum(data)
checksum = data.unpack("n*").inject(0) { |s, x| s + x }
((checksum >> 16) + (checksum & 0xffff)) ^ 0xffff
end

require 'socket'

class UDP_Faker

@@id = 1234 - 1

def initialize
@s = Socket.new(Socket::PF_INET, Socket::SOCK_RAW, Socket::IPPROTO_RAW)
@s.setsockopt(Socket::IPPROTO_IP, Socket::IP_HDRINCL, 1)
end

def send(src, sport, dst, dport, payload = '')
dst_numeric = dst.split(/\./).map { |x| x.to_i }
to = [ Socket::AF_INET,
dport, dst_numeric, '' ].flatten.pack('snCCCCa8')
packet = make_ip_header([
[ '01000101', 'B8' ], # version, hlen
[ 0, 'C' ], # tos
[ 28 + payload.size, 'n' ], # total len
[ @@id += 1, 'n' ], # id
[ 0, 'n' ], # flags, offset
[ 64, 'C' ], # ttl
[ 17, 'C' ], # protocol
[ 0, 'n' ], # checksum
[ ip2long(src), 'N' ], # source
[ ip2long(dst), 'N' ], # destination
])
packet << make_udp_header([
[ sport, 'n'], # source port
[ dport, 'n' ], # destination port
[ 8 + payload.size, 'n' ], # len
[ 0, 'n' ] # checksum (mandatory)
])
packet << payload
@s.send(packet, 0, to)
end

private

def ip2long(ip)
long = 0
ip.split(/\./).reverse.each_with_index do |x, i|
long += x.to_i << (i * 8 )
end
long
end

def ipchecksum(data)
checksum = data.unpack("n*").inject(0) { |s, x| s + x }
((checksum >> 16) + (checksum & 0xffff)) ^ 0xffff
end

def make_ip_header(parts)
template = ''
data = []
parts.each do |part|
data += part[0..-2]
template << part[-1]
end
data_str = data.pack(template)
checksum = ipchecksum(data_str)
data[-3] = checksum
data.pack(template)
end

def make_udp_header(parts)
template = ''
data = []
parts.each do |part|
data += part[0..-2]
template << part[-1]
end
data.pack(template)
end

end

testRun = UDP_Faker.new
loop do
# Source IP Port Destination IP Port Payload
testRun.send('203.64.36.24', 2069, '124.191.161.6', 81, 'Blob: here comes the data ...')
end
# TODO: Loop through a range of source IP addy's.
# Return response from server. Use correctly formatted blob.

In a similar vein, but long since shutdown, the guys at Hackers Choice provided some excellent C code for flooding TCP connections, which I also found useful in this project in order to conduct some stress to break testing. Understandably, some people might misuse this script, but for internal uses, I found it extremely useful to flood the TCP/IP stack. You can dowload the code here: flood_connect.c

It's usage is along the lines of this:

Options:
-S use SSL after TCP connect (not usuable with -u, sets port=443)
-u use UDP protocol (default: TCP) (not usable with -c)
-p port port to connect to (default: %d)
-f forks number of forks to additionally spawn (default: 0)
-i file data to send to the port (default: none)
-n connects maximum number of connects (default: unlimited)
-N delay delay between connects in ms (default: 0)
-c close after connect (and sending data, if used with -i)
use twice to shutdown SSL sessions hard (-S -c -c)
-C delay delay before closing the port (for use with -c) (default: 0)
-d dump data read from server
-D delay delay before trying to read+dump data from server (default: 0)
-e stop when no more connects possible (default: retry forever)
-k no keep-alive after finnishing with connects, terminate!
-v verbose mode
TARGET target to flood attack (ip or dns)

]]> http://altentee.com/2007/faking-it-udp-packets-that-is/feed/ 0