Humair's Blogs

Important IPv6 Addresses

Humair — Wed, 02 May 2012 05:32:41 +0000

For easy reference, I’ve listed some important IPv6 address ranges below.

0:0:0:0:0:0:0:0 – equals ::. This is equivalent to IPv4′s 0.0.0.0 IP address. It is usually the source address of a host using DHCP stateful configuration and is also referred to as a non-routable meta-address used to designate an invalid, unknown, or non applicable target.

0:0:0:0:0:0:0:1 – equal to ::1. This is the equivalent of the 127.0.0.1 which is the Internet protocol (IP) loopback address also referred to as the “localhost”.

0:0:0:0:0:0:192.168.1.2 – in a mixed IPv6/IPv4 network environment, an IPv4 address is appended as the last 32 bits of an IPv6 address.

2000::/3 – the global unicast address range.

FC00::/7 – the unique local unicast range.

FE80::/10 – the link local unicast range.

FF00::/8 – the multicast range.

3FFF:FFFF::/32 – reserved for examples and documentation.

2001:0DB8::/32 – also reserved for examples and documentation

2002::/16 – used with 6to4 tunneling.

As an example of implementation, 2001:0DB8:0123::/48 stands for the network with addresses 2001:0DB8:0123:0000:0000:0000:0000:0000 through 2001:0DB8:0123:FFFF:FFFF:FFFF:FFFF:FFFF.

Networking: Blocking Access to a Website via Extended Access List [Video]

Humair — Mon, 16 Apr 2012 11:38:02 +0000

This video demonstrates how to use an extended access list to prevent specific hosts from accessing a website. In this lab I use two Cisco 2811 routers [IOS 12.4(15)T1] and two Cisco 2950-24 switches [IOS 12.1(22)EA4].

Networking: Spanning Tree Protocol Basics [Video]

Humair — Sun, 15 Apr 2012 09:55:26 +0000

This video covers some of the basics of how Spanning Tree Protocol (STP) works in a network. To learn more about Spanning Tree Protocol see some of my prior blogs on STP.

Algebra: Linear Equations (Coin Problem) [Video]

Humair — Sun, 15 Apr 2012 07:12:21 +0000

I created and uploaded this video to youtube back in 2009. This video demonstates how to solve a simple algebra coin problem.

Chemistry: Calculate the Mass of an Atom [Video]

Humair — Sun, 15 Apr 2012 06:05:07 +0000

I created and uploaded this video to youtube back in 2009. This video demonstrates how to solve a simple chemistry problem. I calculate the mass of a Chlorine atom.

Python – Implementing Caching in Your Applications via Dictionaries

Humair — Fri, 06 Apr 2012 08:54:51 +0000

In this blog I demonstrate how you can implement and take advantage of caching in your Python scripts/applications.

Caching allows you to complete tasks more rapidly by storing and reusing results for repeated operations using the same criteria. For example, consider a function that takes several arguments and performs a complex calculation. What if you passed the same arguments to this function ten times; well, without caching, the same operation and complex calculation will be performed ten times.

Fortunately, if a caching scheme is implemented correctly, the application will perform the complex calculation only once and save the arguments and calculated results; if the same exact arguments are passed to the function again, the application will know that the calculation has been done in the past and can just return the prior results instead of performing a recalculation. As you can imagine, application performance can greatly be improved by caching; this is the reason most all high-traffic commercial web applications implement some caching scheme.

For this blog, I created a Python application that calculates the molecular/formula mass of some simple compounds. The molecular/formula mass of a compound is the sum of atomic masses of all its component elements. For example, the molecule H2O or water is equal to a molecular mass of 18.016 amu [(2 x atomic mass of H) + (1 x atomic mass of O)].

Below is the Python function I created that takes a molecular/formula string as an argument, parses the respective information, and calculates the molecular/formula mass. The element data is pulled from an external text file which holds the symbol and atomic mass for the respective element.

Python function that calculates molecular mass

In the above function, the second to last line saves the results to a dictionary and saves the respective passed in arguments as the keys. Now, if you look at the first four lines of the function, you can see that upon entering the function the same dictionary is checked to see if the arguments passed in were already passed in prior – if so, the saved results are returned, skipping the entire recalculation and saving time.

To prove that the caching mechanism is really improving performance, I wrote a function called ‘calculateTime’ which takes the molecular formula as a string and times how long it takes to calculate the molecular/formula mass. Below is the function code.

Python function for timing how long it takes to calculate the molecular mass

In the test code below, you can see I call the ‘calculateTime’ function four times. The first three times, the molecular formula passed in as an argument is different in each case. However, in the fourth call to the ‘calculateTime’ function, you can see I used the same argument as the third call to the function. I would expect the fourth call to return much faster than the other three as the same arguments were used for the call prior and the results should have been cached.

Python molecular mass test code

The ‘calculateTime’ function prints out the time in seconds it took to return a result. You can see in the fourth call there is a huge jump in calculation time for the ‘calculateMolecularMass’ function. You’ve just witnessed caching at work. This is a relatively simple program; just imagine how much time can be saved in a huge commercial system.

Python molecular mass test program results

You can download the full source code for this application from the download section of this website.

Coding a XenServer Client in Python – Monitoring Multiple VMs via Multiple Threads

Humair — Fri, 30 Mar 2012 08:08:10 +0000

HueXenClient - XenServer client written in Python using the Citrix XenAPI

In some prior blogs I had written about developing an ESXi client in Java which could connect to a VMware ESXi server and perform some management tasks. In this blog, I will describe developing a Cirtrix XenServer Client in Python that connects to a Citrix XenServer or XenServer pool; the client can also perform management tasks and provides some advanced monitoring features.

HueXenClient is the name of the program; it was written to demonstrate the possibilities of what can be done using the Citrix XenAPI. The most advanced feature of the program is the capability to monitor multiple VMs simultaneously for loss of network connectivity. The program acts as a management station and pings the VMs via internal mechanism by creating its own ICMP packets and sending the ping request.

This program was written in a short time-span; even-so, I have included proper error/exception handling for all issues I came across during testing. I will be adding on to this application over the next few releases which will be available on GitHub and on the download section of this website. For the latest code, you should download from GitHub.

Development Environment Setup:

HueXenClient is written in Python and uses the included Tkinter GUI library in addition to the Python megawidgets library and the Citrix XenAPI for XenServer 6.0.

You can use whatever editor you like. I used the Eclipse program and the PyDev plug-in. It should also be mentioned that this program was developed, run, and tested on a Windows 7 machine. Although, it should theoretically work with Linux, this has not been tested with Linux and some of the libraries/code may behave differently.

If you download the program from GitHub, you will have to download the Python megawidgets library separately and appropriately link to all the libraries. If you download the code from my personal website, I have included the entire Eclipse project with respective libraries within the download package. However, you will still need to install Eclipse and the PyDev plug-in if that’s what you choose to use.

Testing Environment Setup:

Citrix XenServer Pool Setup

This program was developed, run, and tested on a Windows 7 machine. It was tested against a XenServer setup which consisted of two XenServers in a XenServer pool. Nine VMs existed across both servers combined. Each VM only had one NIC adapter and IP assigned to it. Currently the VM Network Monitoring feature of the application only supports monitoring a VM with one NIC and IP assigned. Also, XenTools must be installed on the respective VM for many of the application functions to work. Additionally, in my setup, all hosts and VMs were part of the same network.

Running the Program:

I used Windows 7 as the operating system during the development process. To run the program from Eclipse, make sure you have the Pydev Eclipse plugin installed. Right click Eclipse and “Run as administrator”. You must run as administrator or root as the application opens sockets and sends ICMP packets without depending on the operating system. If you downloaded the zip file from my website, I have included all the libraries you need in the zip file with the entire Eclipse project.

Connecting to the master and slave host of the XenServer pool:

You must enter the IP address of the XenServer pool master host before attempting to connect, otherwise, you must select the ‘Login to slave host option’ from the ‘Options’ menu as shown below before connecting. Note, you can only perform operations when connecting to the master host. You can only view VMs and “Filter powered-on VMs by host” when connecting to a slave host.

HueXenClient - connecting to a slave host of a XenServer Pool

VM Network Monitoring Feature:

Currently the VM Network Monitoring feature of the application only supports monitoring a VM with one NIC and IP assigned. XenTools must also be installed on the respective VM. The VM Network monitoring feature is a check mark option under the “Options” menu in the toolbar. It will be grayed-out until you select a VM from the dropdown box. Once you select the “Start network monitoring on VM” option from the menu, the network connectivity to the VM is monitored by the application via ICMP ping packets. Two pings are sent around every 5 seconds. If two consecutive pings are missed, a snapshot of the VM is automatically created and the VM stops being monitored. This is demonstrated below using a single VM and by disabling the VM’s adapter so that the pings are intentionally missed.

It is important to remember that that the application is monitoring the VM via external pings, so you must ensure that the application has IP reach-ability to the VM you would like to monitor.

1.

HueXenClient - enabling network monitoring on a VM

XenCenter - disabling the network adapter of the VM being monitored

XenCenter - snapshot of VM automatically created after two consecutive pings are missed

VM Network Monitoring on Multiple VMs Simultaneously:

Since the application is using threads, simultaneous VM network monitoring is supported. This feature is pretty cool and implementing it was a bit of a challenge. I used an open source python ping implementation which had to be modified to work correctly with my application. Since ICMP does not innately have a concept of ports, I had to implement a way for the correct VM to receive the response, otherwise messages are received by all listeners. I accomplished this by creating a unique hash for each thread that associates it with the respective VM.

One important thing to remember is that in an app like this where multiple threads are running in the background, you want to make sure you implement a solution where the threads are killed when the application is exited. I implemented the below code in both the ‘Disconnect’ button and the ‘Exit’ option in the menu. Upon exit, it loops through all the VMs and if needed gets its monitoring object and shuts it down, which in turn shuts down the associated thread for that VM which is sending out the pings. Pretty cool!

HueXenClient code - upon exiting app, shuts down any VM monitoring threads

As you can see this app can be pretty useful and can easily be expanded. That’s it for this tutorial; feel free to dive into the code!

EIGRP – Best Path Selection

Humair — Tue, 27 Mar 2012 10:58:49 +0000

By default EIGRP uses bandwidth and delay of the line to determine the best path to a remote network. However, if desired, EIGRP can use a composite of four metrics: bandwidth, delay, reliability, and load. Maximum transmission unit (MTU) is not used in EIGRP calculations but is a required parameter in some EIGRP-related commands. Also, by default, EIGRP will provide equal-cost load balancing across up to four links. You can disable load balancing by setting the ‘maximum-paths’ to ’1′. In this lab I use four Cisco 3725 routers [IOS 12.4(15)T10] to demonstrate EIGRP path selection behavior on Cisco routers. Below is a diagram of my setup.

EIGRP lab topology

My initial topology and routing table is displayed below.

Initial R1 EIGRP topology table

Initial R1 EIGRP routing table

As you can see from the above, since EIGRP provides equal-cost load balancing across for up to four links, both equal routes to the 12.0.0.0/30 network are in the topology and routing table. Below, I lower the bandwidth of the 10.0.13.0/30 link to 50 MB and since bandwidth is a metric used by EIGRP to determine the best path, you can see that the 10.0.13.0/30 link remains in the topology table but is removed from the routing table. Only the 11.0.0.0/30 link to the 12.0.0.0/30 network remains in the routing table.

R1 EIGRP topology table after lowering the bandwidth of the 10.0.13.0/30 link

R1 EIGRP routing table after lowering the bandwidth of the 10.0.13.0/30 link

Setting-up Basic iBGP and eBGP on Cisco Routers

Humair — Thu, 15 Mar 2012 14:32:51 +0000

The Border Gateway Protocol (BGP) is a protocol used to make core routing decisions on the Internet. BGP is commonly mislabeled or referred to as an IP routing protocol. However, it is not a routing protocol; rather, it is a TCP application that carries routing information with it. It is better referred to as a reach-ability protocol rather than a routing protocol.

External BGP (eBGP) helps connect networks with different Autonomous Numbers (AS) to each other. eBGP is used heavily by Internet service providers to establish routing between one another; this is especially the case if they are multihomed (for more info on multihoming, see my prior blog, Single/Dual and Multihomed Connections). Internal BGP (iBGP) is a BGP connection within the same AS and is used as a way to exchange BGP information between multiple BGP border routers.

In this lab, I use three Cisco 3725 routers [IOS 12.4(15)T10] to demonstrate how to setup basic iBGP and eBGP on Cisco routers. I have two routers, R1 and R2, in AS 200 and setup iBGP between them. R3 is in AS 400 so I setup eBGP between R1 and R3. I configured loopback addresses on both R2 and R3 to confirm communication is good between them; this also helps confirm that BGP is working properly. Below is the lab setup I used.

BGP lab setup

The configuration I used to setup the routers is shown below. Note, in BGP, the redistribution of static and connected routes into BGP is enabled with the “redistribute connected” and “redistribute static” commands. I use the “redistribute connected” command below.

R1 Configuration

- enable
- conf t
- router bgp 200
- redistribute connected
- neighbor 180.0.0.2 remote-as 400
- neighbor 10.0.0.2 remote-as 200
- exit
- exit
- write

R2 Configuration

- enable
- conf t
- router bgp 200
- redistribute connected
- neighbor 10.0.0.1 remote-as 200
- exit
- exit
- write

R3 Configuration

- enable
- conf t
- router bgp 400
- redistribute connected
- neighbor 180.0.0.1 remote-as 200
- exit
- exit
- write

The “show ip bgp summary” command outputs the identified neighbors and their associated Autonomous System (AS) number. The current state of the neighbor relationship is also listed. If all is working, this show display as ‘established’ or show the count of prefixes learned. The prefixes indicate the prefixes learned from the respective neighbor and confirms the state is established.

Below, from the “show ip bgp summary” command run on both R2 an R3, you can see that the respective neighbor is listed and the state is established with each having learned three prefxes.

R2 - "show ip bgp summary" output

R3 - "show ip bgp summary" output

Next, I display the BGP table of R2 via the “show ip bgp” command. As you can see, all respective routes have been learned. Further, I ping from the loopback on R2 (2.2.2.2) to the loopback on R3 (3.3.3.3) to confirm there is no issue with communication. If you are having issues establishing a neighbor relationship, you may want to enable “logging console” and “logging buffer”; this will allow you to see triggered events on the screen and via the “show logging” command.

R2's BGP table and confirming communication via ping

Single/Dual and Multihomed Connections

Humair — Mon, 12 Mar 2012 14:04:47 +0000

Network engineers will sometimes speak of connections to their ISP(s) in terms of single homed, dual homed, single multihomed, and dual multihomed. Here is a breakdown and clarification of what this terminology means:

- Single Homed (1 link per ISP, 1 ISP)
- Dual Homed (2+ links per ISP, 1 ISP)
- Single Multihomed (1 link per ISP, 2+ ISPs)
- Dual Multihomed (2+ links per ISP, 2+ ISPs)

Obviously, if you are a datacenter or large enterprise, dual multihomed is definitely costly but the way to go. A dual multihomed setup can help with redundancy, but just as importantly decisions can be made, for instance by BGP (Border Gateway Protocol), on the best path to reach various destinations.. Below are some graphical examples.

Single Homed

Single Homed

Dual Homed

Dual Homed

Single Multihomed

Single Multihomed

Dual Multihomed

Dual Multihomed