DevCentral Docs and Tips (Video)

v11: RDP Access via BIG-IP APM–Part 1

devcentralteam@f5.com (F5 DevCentral Team) — Tue, 13 Sep 2011 02:00:00 GMT

I wrote an article several months back on auto-launching Remote Desktop sessions with APM. With the introduction of BIG-IP APM v11, there is a new built-in capability to support a full webtop. This means that server, desktop, or other resources can be placed on the webtop for users to select once logging in. In this first example, I’ll set up a static internal resource for users to connect to after logging in.

Create the Webtop

After logging in to the BIG-IP, open up the Access Policy tab and select Webtops->Webtop List and then click Create (or you can hit the “+” circled to the right of the Webtop List.) Give the Webtop a meaningful name and the type needs to be Full as show in Figure 1.

Create the RDP Resource

Still in the Access Policy tab, click Application Access->Remote Desktops->Remote Desktops and then click Create. There are a number of fields here, but for this example the only ones that need to be set are the Type (RDP), the Destination (Server or Desktop hostname or IP), and Auto Logon (Enable). When Auto Logon is selected, the username, password, and domain source variable fields are shown. I accepted the defaults.

Create the Access Policy

Now that the two custom objects for the RDP Webtop are created, I’ll create the access policy (and virtuals) with the Network Access Setup Wizard for Remote Access under the Wizards tab. I create all my access policies this way, the wizard is very thorough and eliminates my tendency to overlook an object or misconfigure one, not to mention the time savings. In the first screen, I disabled AV checks (though in production I wouldn’t recommend this) as shown in Figure 3 below.

Next I create a new authentication resource (you can select existing if this is not a new installation), utilizing my test active directory server.

Next I configure the lease pool. It’s just me in my test lab, so I only create a single client address, but you’ll likely need to choose the IP address range.

The next step is for network access configuration. Corporate policies will dictate whether all traffic is forced through the tunnel or if split-tunneling is appropriate. For this example, I stuck with forcing all traffic through the tunnel to minimize the necessary configuration to show the features.

I only have one name server, my ad01 directory server, so I enter that and leave the rest blank.

Next I’ll enter the VIP address and leave the http->https redirect virtual enabled.

At this point, I review the configuration and click next. If there are any errors, you can return to previous steps in the wizard and make corrections. Before clicking Finished in the next screen, I need to edit the access policy.

Once in the policy editor, click on the Logon Page object and set Field 3 from none to text and use domain as the post and session variable name. Then below in the Logon Page Input Field #3 text box, enter Domain.

Next, click on the Resource Assign object and then click Add/Delete in the expression. I need to replace the webtop the network access wizard created and I need to select the RDP Resource I created.

Close out the policy and then click Finished in the Setup Summary screen. For my configuration I need to snat the traffic, so I enabled snat-automap on the virtual created by the wizard. Because I made changes to the policy, I need to re-apply it, so in the Access Policy tab I clicked on Access Profiles and then selected my profile and clicked Apply Access Policy.

That completes the configuration steps. Now it’s time to test.

Testing the Configuration

First I open a browser and navigate to my vip, https://10.10.20.30.

After login, my RDP resource is shown on my Webtop, along with my network access.

After clicking the rdptest icon, I am logged in automatically to my server.

It seems like a lot of steps, but I configured this in less than five minutes, which is far more efficient and far less error-prone than the previous solution. The video below shares the same steps covered here in screen captures.

BIG-IP APM RDP Webtop

Conclusion

This solution introduces a full Webtop environment for BIG-IP APM in version 11, which I took advantage of for statically configuring RDP resources for clients. In part 2, I’ll introduce a dynamic option for the RDP resource.

Link Tracking With iRules - Part 3 - URI Filtering

devcentralteam@f5.com (F5 DevCentral Team) — Wed, 06 Apr 2011 08:00:00 GMT

This is the third article in a series on building link tracking functionality with iRules. The previous articles were

In the first article, I focused on building the core link tracking logic and in the second I added the logic to implement a simple output filter to only list the URI’s you are interested in seeing the statistics for. In this article I will build on additional functionality, so I would highly suggest taking a peek at the first two before continuing.

Now, if you are like me, there are a lot of HTTP requests that go into your application that you don’t care about keeping tracking data on. The first two articles did nothing with regards to pre-filtering the URIs coming in to the iRule and left unattended, will get a fairly large list. This article will discuss how to add some basic filtering to the incoming URIs that are added to the link tracking database.

The Control Panel UI Elements

In order to list and store the URI filters in this application, I created a control panel to the left of the URI tracking results.

The control panel consists of the subtable name, the number of links currently in the tracking database, global control links for clearing the data and filters, the URI filter list, and a text box to allow for the user to add new URI filters.

I’d like to note here, that I’ve expended a minimal amount of UI design in this iRule. I have no sense of color, so you are just going to get plain HTML tables out of me. I’d love to get someone with some artistic abilities to fix up the styles in this and make it look nice. Anyone?

Anyway, back to the contents of the control panel..

Table Names

The table names, as in the previous examples, are derived from the name of the virtual server the iRule is attached to. This allows for applications on different virtual servers to have separate data stores. In this example, I’m just storing these as local variables in the HTTP_REQUEST handler event.

   1: set TABLE_LINK    "LINK_TRACKING_[virtual name]";

   2: set TABLE_FILTERS "LINK_TRACKING_FILTERS_[virtual name]";

Link Count

The number of items in the link tracking database is easily determined by using the “table keys” command with the “-count” argument. This will return the number of keys that would have been returned from the command if the “-count” parameter wasn’t specified.

   1: set count [table keys -subtable $TABLE_LINK -count]

   2: append content "<tr><td align='right'><b>Link&nbsp;Count</b></td><td>$count</td></tr>"

Controls

I’ve moved the "Clear Data” control from the report listing into the Controls section of the control panel. What that I know have three control commands:

/linkcleardata - Clear all link tracking data from the table. In the handler for this command, I simply issue the “table delete” command on the $TABLE_LINK table.
/linkclearfilters - Clear all filters from the filter table. In this handler, I use the “table delete” command to erase the $TABLE_FILTERS table.
/linkadmin - reload the iRule to refresh the result table.

   1: append content {<tr><td align='right' valign='top'><b>Controls</b></td>

   2:   <td>

   3:     <a href='/linkcleardata'>Clear Data</a><br/>

   4:     <a href='/linkclearfilters'>Clear Filters</a><br/>

   5:     <a href='/linkadmin'>Refresh</a>

   6:   </td>

   7: </tr>}

   8: .

   9: .

  10: "/linkcleardata" {

  11:   table delete -subtable $TABLE_LINK -all;

  12:   HTTP::redirect "http://[HTTP::host]/linkadmin/Link+Tracking+Cleared"

  13: }

  14: "/linkclearfilters" {

  15:   table delete -subtable $TABLE_FILTERS -all;

  16:   HTTP::redirect "http://[HTTP::host]/linkadmin/Link+Filters+Cleared"

  17: }

Adding New URI Filters

Adding new filters is relatively simple. An HTML input form is created in the control panel and I’ve overridden the onKeyDown handler to look for the enter key (keyCode == 13) and when it’s hit, the page is redirected to the “/linkaddfilter” command passing in the new filter as the rest of the URI.

The add filter processing code will extract all the values past the initial “/linkaddfilter/” in the URI and insert that into the $TABLE_FILTERS table. This table is just being used to store the filter patterns. In this case I really don’t care what the value is, nor if it’s already in the table so a single “table add” command is made to insert it for future processing.

   1: append content {<tr><td align='right'><b>Add&nbsp;Filter</b></td><td>

   2:   <input type='text' id='new_filter' value='' size='15'

   3:     onkeydown="if (event.keyCode == 13) { window.location.assign('/linkaddfilter/' + encodeURI(getElementById('new_filter').value)) }"/>

   4:   </td></tr>}

   5: .

   6: .

   7: "/linkaddfilter/*" {

   8:   set f [string range ]HTTP::uri[ ]string length "/linkaddfilter/"[ end]

   9:   if { "" != $f } {

  10:     table add -subtable $TABLE_FILTERS $f 1 indefinite indefinite;

  11:   }

  12:   HTTP::redirect "http://[HTTP::host]/linkadmin/Filter+Added";

  13: }

Listing And Removing URI Filters

As I mentioned in the previous section, the URI filters are stored in the $TABLE_FILTERS table. The UI listing for these filters simply iterates through all the keys in the table (which are the filters) and inserts them in a list. Before the actual filter string, I’ve inserted a "[x]” link that will allow for removing the filter in a similar way that I did for removing individual URIs from the link tracking database.

If the delete link is clicked, the filter is extracted from the URI and the “table delete” command is called with that filter as the key. A HTTP redirect is then made to refresh the page and show the updated list of URI filters.

   1: append content "<tr><td align='right' valign='top'><b>URI&nbsp;Filters</b></td><td>"

   2: foreach key [table keys -subtable $TABLE_FILTERS] {

   3:   append content "\[<a href='/linkremovefilter/$key'>x</a>\] $key<br/>";

   4: }

   5: append content "</td></tr>";

   6: .

   7: .

   8: "/linkremovefilter/*" {

   9:   set val [string range ]HTTP::uri[ ]string length "/linkremovefilter/"[ end]

  10:   if { "" != $val } {

  11:     table delete -subtable $TABLE_FILTERS $val;

  12:   }

  13:   HTTP::redirect "http://[HTTP::host]/linkadmin/Filter+Deleted";

  14: }

Processing The URI Filters

The default handler for all URIs that are not handled by the iRule previously inserted all URIs with the “table” command. I’ve added additional logic to look for the existence of any filters and process them. I’m using the $match variable to determine if the URI is to be stored. If there are no filters in the filter table, then I’m assuming that all URIs will get added to the tracking database. But, if there are some filters in the filter table, I iterate through each of them with the “foreach” command and use the “string match” command to see if the incoming URI matches each individual filter. The “string match” command is a great tool for performing wildcard comparisons. It is much lighter weight than regular expressions and usually does just what you need. If a match occurs, I break out of the iteration and proceed to entering the value into the tracking database.

   1: default {

   2:   set match 1;

   3:   set c [table keys -subtable $TABLE_FILTERS -count]

   4:   if { $c != 0 } {

   5:     set match 0;

   6:     foreach key [lsort ]table keys -subtable $TABLE_FILTERS[] {

   7:       set m [string match $key ]HTTP::uri[];

   8:       if { 1 == $m } {

   9:         set match 1;

  10:         break;

  11:       }

  12:     }

  13:   }

  14:   if { $match ==  1} {

  15:     if { [table incr -subtable $TABLE_LINK -mustexist ]HTTP::uri[] eq ""} {

  16:       table set -subtable $TABLE_LINK [HTTP::uri] 1 indefinite indefinite;

  17:     }

  18:   }

  19: }

Video Walkthrough

Link Tracking With iRules - Part 3 - URI Filtering

Conclusion

So, with the addition of this article, you you not only have the ability to tracking and report on link metrics, but you can only store data on the ones that you are concerned about. The logic for the filter table could easily be modified to use it as a negative filter (ie. allow URI’s that don’t match the filters) but I’ll leave that for the reader to develop.

Still More To Come!

I’m not done yet. In the next addition to this iRule, I will add more advanced functionality to allow tracking external referral links.

Get The Source

The source code for this application can be downloaded the LinkTracking3 topic in the iRules CodeShare.

Link Tracking With iRules - Part 1

devcentralteam@f5.com (F5 DevCentral Team) — Wed, 16 Mar 2011 17:29:58 GMT

One common request that application developers ask of their network admins is to report on the amount of times links in their applications are requested. Various analytics packages including page trackers can be added to the application pages to store those values but in this article, I’ll show you how to create a very simple link tracker with a transparent iRule applied to your virtual server of choice.

Storing The Data

The first step is to take the incoming URI’s and store a count of the number of times they have been requested. In this application, I will be using the table command to create and store the data in a subtable (for more information on the table command, check out this excellent series of articles on it’s various uses and features).

I’ve created a dynamic name for the table that consists of the prefix “LINK_TRACKING_” and is followed by the name of the virtual server that the iRules is applied to. This is beneficial in that it allows you to have a separate data store for different applications running on different virtual servers. The value of the table name is stored in the TABLE_LINKDATA variable.

Next, an attempt is made to increment the link count of the current URI (in the HTTP::uri value) with the “table incr” command. If the entry doesn’t exist yet (the first time in the system), the if condition will fail and a new entry will be inserted with the “table set” command with a link count of 1. That’s it! Now all your links are stored with their reference counts.

   1: set TABLE_LINKDATA "LINK_TRACKING_[virtual name]"

   2: if { [table incr -subtable $TABLE_LINKDATA -mustexist ]HTTP::uri[] eq ""} {

   3:   table set -subtable $TABLE_LINKDATA [HTTP::uri] 1 indefinite indefinite;

   4: }

Reporting The Metrics

Storing the data is only half of the solution, there needs to be some way to view the data once it is in the system table. This is achieved with the following iRule code where I create a HTML page response containing a HTML table with a row for each entry in the link tracking data table. The first column contains the URI and the second is it’s view count. The generated page is then returned to the browser via the HTTP::respond command.

   1: set content {<html><head><title>Link Tracking</title></head><body><center>

   2:   <table border='1'><tr><th colspan='2'><a href='/linkcleardata'>Clear Data</a></th></tr>

   3:   <tr><th width='100%'>URI</th><th>Views</th></tr>}

   4: foreach key [table keys -subtable $TABLE_LINKDATA] {

   5:   append content "<tr><td>$key</td><td>[table lookup -subtable $TABLE_LINKDATA $key]</td></tr>";

   6: }

   7: append content "</table></center></body></html>";

   8: HTTP::respond 200 Content $content;

Cleaning Up

You may notice the “Clear Data” hyperlink I created in the reporting page. When storing the data in the system table, I specified a time of “indefinite” for the lifetime of the data. This means that it lives in the system table for the lifetime of the TMM process. It would only be prudent to provide a way to clean up this table from time to time and that is where the “Clear Data” link comes in. It will link back to the iRule and issue the “table delete” command to clear out the contents of the link data table.

   1: table delete -subtable $TABLE_LINKDATA -all;

Putting It All Together

Below is the full iRule to implement basic link tracking. All normal requests will fall through the “default” case in the switch statement and add the view counts to the link table. I’ve created two special URI’s to handle the reporting and data management

“/linkadmin” - This will generate the HTML response page and return it to the browser with all the links and their view counts.
“/linkcleardata” - This will erase the contents of the link data table.

   1: when HTTP_REQUEST {

   2:   set TABLE_LINKDATA "LINK_TRACKING_[virtual name]"

   3:   switch [string tolower ]HTTP::uri[] {

   4:     "/linkadmin" {

   5:       set content {<html><head><title>Link Tracking</title></head><body><center>

   6:         <table border='1'><tr><th colspan='2'><a href='/linkcleardata'>Clear Data</a></th></tr>

   7:         <tr><th width='100%'>URI</th><th>Views</th></tr>}

   8:       foreach key [table keys -subtable $TABLE_LINKDATA] {

   9:         append content "<tr><td>$key</td><td>[table lookup -subtable $TABLE_LINKDATA $key]</td></tr>";

  10:       }

  11:       append content "</table></center></body></html>";

  12:       HTTP::respond 200 Content $content;

  13:     }

  14:     "/linkcleardata" {

  15:       table delete -subtable $TABLE_LINKDATA -all;

  16:       HTTP::redirect "http://[HTTP::host]/linkadmin"

  17:     }

  18:     default {

  19:       if { [table incr -subtable $TABLE_LINKDATA -mustexist ]HTTP::uri[] eq ""} {

  20:         table set -subtable $TABLE_LINKDATA [HTTP::uri] 1 indefinite indefinite;

  21:       }

  22:     }

  23:   }

  24: }

Video Walkthrough

Link Tracking With iRules - Part 1

More To Come!

There are several ways to enhance this iRule that I will be illustrating in future articles over the next few weeks. I’ll look into building URI filters to allow you to only track certain URIs as well as adding filtering features in the generated link count report. Be on the lookout!

Get The Source

The source code for this application can be downloaded the LinkTracking topic in the iRules CodeShare.

2x5-Minute iRules - Timing

devcentralteam@f5.com (F5 DevCentral Team) — Thu, 03 Mar 2011 20:53:00 GMT

Timing is a command in iRules that triggers the system to track the number of cycles each event in an iRule consumes. Deb has covered timing previously in iRules Optimization 101 – #05 – Evaluating iRule Performance, so I took that and a presentation someone internally put together from that information and recorded a walkthrough on what makes timing tick. (ba-dah, ching!)

iRule Timing Part 1

I also took the opportunity to dust off my pycontrol skills and whipped up a script that will do some load testing against a virtual with your iRule applied, then download and crunch the stats specific to your platform cores/speeds so the numbers should be accurate.

iRule Timing Part 2

I uploaded the script to the iControl codeshare, titled pycontroliRuleTiming. A sample of the output from the script is below:

jrahm@jrahm-dev:/var/tmp$ ./iRuleStats.py 10.10.20.5 admin timing_test http://10.10.20.50
Please enter your password:
Password:

Resetting Statistics for the timing_test iRule

Running load test to host http://10.10.20.50
### Raw Data ###
Event: HTTP_REQUEST
        STATISTIC_RULE_AVERAGE_CYCLES = 41767
Event: HTTP_RESPONSE
        STATISTIC_RULE_AVERAGE_CYCLES = 92363

### iRule timing_test Performance Results
        BIG-IP LTM 3600 has 3413568000 availabe CPU Cycles (2 cores, 2133.480 MHz)
        Average Cycles/sec:     134130
        CPU Utilization/req:    0.00392931970302 percent
        Max Requests/sec:       25449

Happy coding!

Related Articles

BIG-IP CPU Visualization with the Google Visualization API

devcentralteam@f5.com (F5 DevCentral Team) — Wed, 23 Feb 2011 22:21:00 GMT

In previous articles, we have explored using the Google Chart APIs to integrate static charts and graphs with iControl and iRules to build monitoring applications.

In this article, I’m going to move beyond the static charting APIs and take a look at the more complex Google Visualization API. It is a JavaScript library that allows you to embed interactive charts, graphs, or other graphics onto a webpage.

For this application, I will take a look at the CPU metrics on a BIG-IP and build a dynamic gauge based dashboard.

The Application

There are several approaches to building a dashboard and for this example, I've build a Windows Form application in C#. The core of the app is the WebBrowser control which essentially wraps the Internet Explorer COM control up in a nice little package. I then use the iControl Assembly to get the metrics from the BIG-IP, and then dynamically execute JavaScript functions from the C# code to manipulate the gauges.

The main components to the application are described in the following sections.

Connecting to the BIG-IP

I use a iControl.Dialogs.ConnectionDialog, available from the iControl Assembly, to connect to the BIG-IP. If you use the iRule Editor, this may look familiar… The DoConnect() method will attempt to connect to the BIG-IP with the ConnectionDialog and, if it succeeds, then build the initial browser content for the WebBrowser control. It then updates the charts with the latest data and then triggers the timer to start a update cycle. Each time the timer triggers, another data collection is made and the charts are updated with the updateCharts() method.

   1: private void DoConnect()

   2: {

   3:     if (timer1.Enabled)

   4:     {

   5:         timer1.Enabled = false;

   6:     }

   7:     else

   8:     {

   9:         DialogResult dr = _cd.ShowDialog();

  10:         if (dr == DialogResult.OK)

  11:         {

  12:             loadBrowserContents(buildHTMLContent());

  13:             updateCharts();

  14:             timer1.Enabled = true;

  15:         }

  16:     }

  17:     updateMenus();

  18: }

Creating HTML Page

The first time a connection is made to the LTM, the buildHTMLContent() method is called which makes a call to the get_cpu_usage_extended_information() iControl method to extract the CPU metrics for the given BIG-IP. In this example, I’m only using the first host. With future versions of BIG-IP, you will be able to manage multiple “hosts” within a single BIG-IP system.

An HTML page is created with DIV elements created and named for each CPU. A row in the output table is created for each CPU with 3 gauges for Usage, Speed, and Temperature.

   1: private String buildHTMLContent()

   2: {

   3:     String page_data = "";

4:

   5:     if (_cd.m_interfaces.initialized)

   6:     {

   7:         iControl.SystemCPUUsageExtendedInformation cpu_info =

   8:             _cd.m_interfaces.SystemSystemInfo.get_cpu_usage_extended_information(new String[] { "0" });

9:

  10:         iControl.SystemCPUUsageExtended host_info = cpu_info.hosts[0];

  11:         String host_id = host_info.host_id;

  12:         iControl.CommonStatistic[][] statisticAofA = host_info.statistics;

13:

  14:         String table_rows = "";

15:

  16:         // Loop over CPUs

  17:         for (int i = 0; i < statisticAofA.Length; i++)

  18:         {

  19:             long cpu_id = extractStatistic(statisticAofA[i], iControl.CommonStatisticType.STATISTIC_CPU_INFO_CPU_ID);

20:

  21:             table_rows += "<tr><td>C<br/>P<br/>U<br/>" + cpu_id + "</td>";

  22:             table_rows += "<td class='gauge'><div id='gauge_" + cpu_id + "_0'></div></td>";

  23:             table_rows += "<td class='gauge'><div id='gauge_" + cpu_id + "_1'></div></td>";

  24:             table_rows += "<td class='gauge'><div id='gauge_" + cpu_id + "_2'></div></td></tr>";

25:

  26:         }

  27:         updateTimestamp(true);

  28:         page_data = @"<html><head><title>iControl CPU Gauges</title>

  29:             <style type='text/css'>

  30:             body,td,th { font-family: Tahoma; font-size: 10pt; }

  31:             .gaugex { width:200px;height:200px; }

  32:             </style>

  33:             <script type='text/javascript' src='https://www.google.com/jsapi'></script>

  34:             <script type='text/javascript'>

  35:             google.load('visualization', '1', {packages:['gauge']});

  36:             </script>

  37:             </head>";

38:

  39:         page_data += "<body><center><table border='0'>";

  40:         page_data += table_rows;

  41:         page_data += "</table></center></body>";

  42:         page_data += @"<script type='text/javascript'>

  43:             var chartWidth = 200;

  44:             var chartHeight = 200;

45:

  46:             function setChartSize(w, h) {

  47:                 chartWidth=w;

  48:                 chartHeight=h;

  49:             }

  50:             function drawChart(id, chart_num, label, value) {

  51:                 var data = new google.visualization.DataTable();

  52:                 data.addColumn('string', 'Label');

  53:                 data.addColumn('number', 'Value');

  54:                 data.addRows(1);

  55:                 data.setValue(0, 0, label);

  56:                 data.setValue(0, 1, parseInt(value));

57:

  58:                 var elem = document.getElementById(id);

  59:                 var chart = new google.visualization.Gauge(elem);

60:

  61:                 var usage_options = {

  62:                     width:chartWidth,height:chartHeight,

  63:                     min:0,max:100,greenFrom:70,greenTo:75,yellowFrom:75,yellowTo:90,redFrom:90,redTo:100,

  64:                     minorTicks:5,

  65:                     majorTicks:['0','10','20','30','40','50','60','70','80','90','100']

  66:                     };

  67:                 var fanspeed_options = {

  68:                     width:chartWidth,height:chartHeight,

  69:                     min:0,max:6000,

  70:                     greenFrom:4000,greenTo:4500,yellowFrom:4500,yellowTo:5500,redFrom:5500,redTo:6000,

  71:                     minorTicks:5,

  72:                     majorTicks:['0','1000','2000','3000','4000','5000','6000']

  73:                    };

  74:                 var temp_options = {

  75:                     width:chartWidth,height:chartHeight,

  76:                     min:0,max:100,greenFrom:70,greenTo:75,yellowFrom:75,yellowTo:90,redFrom:90,redTo:100,

  77:                     minorTicks:5,

  78:                     majorTicks:['0','10','20','30','40','50','60','70','80','90','100']

  79:                     };

  80:                 var options = '';

  81:                 if ( chart_num == 0 ) { options = usage_options; }

  82:                 else if ( chart_num == 1 ) { options = fanspeed_options; }

  83:                 else if ( chart_num == 2 ) { options = temp_options; }

84:

  85:                 chart.draw(data, options);

  86:             }

  87:             </script></html>";

  88:     }

89:

  90:     return page_data;

  91: }

Inserting HTML Page in Browser Control

Injecting the HTML contents into the WebBrowser control is as simple as assigning it’s DocumentText property with the HTML contents.

   1: private void loadBrowserContents(String s)

   2: {

   3:     if ( null != s )

   4:     {

   5:         webBrowser1.DocumentText = s;

   6:     }

   7: }

Refreshing Charts

Once the WebBrowser control contains the contents of the page with the embedded functions to update the gauges, the updateCharts() method in this example will query the cpu metrics and make calls into the embedded JavaScript on the page with the WebBrowser’s Document.InvokeScript() method.

The updateChart() method takes as input the id, cpu id, title, and value for the chart. These values are then bundled up into an Object array and passed to the drawChart() JavaScript function with the parameters. The drawChart() JavaScript function then calls the Google Visualization chart object’s draw() method with the supplied options and the chart is then refreshed.

   1: private void updateCharts()

   2: {

   3:     if (_cd.m_interfaces.initialized)

   4:     {

   5:         DoResize();

6:

   7:         iControl.SystemCPUUsageExtendedInformation cpu_info =

   8:             _cd.m_interfaces.SystemSystemInfo.get_cpu_usage_extended_information(new String[] { "0" });

9:

  10:         iControl.SystemCPUUsageExtended host_info = cpu_info.hosts[0];

  11:         String host_id = host_info.host_id;

  12:         iControl.CommonStatistic[][] statisticAofA = host_info.statistics;

13:

  14:         iControl.SystemPlatformCPUs PlatformCPUs =

  15:             _cd.m_interfaces.SystemSystemInfo.get_cpu_metrics();

16:

  17:         // Loop over CPUs

  18:         for (int i = 0; i < statisticAofA.Length; i++)

  19:         {

  20:             iControl.SystemCPUMetric[] CPUMetricA = PlatformCPUs.cpus[i];

21:

  22:             long cpu_index = extractMetric(CPUMetricA, iControl.SystemCPUMetricType.CPU_INDEX);

  23:             long cpu_temp = extractMetric(CPUMetricA, iControl.SystemCPUMetricType.CPU_TEMPERATURE);

  24:             long cpu_fan_speed = extractMetric(CPUMetricA, iControl.SystemCPUMetricType.CPU_FAN_SPEED);

25:

  26:             long cpu_id = extractStatistic(statisticAofA[i], iControl.CommonStatisticType.STATISTIC_CPU_INFO_CPU_ID);

  27:             long cpu_usage_ratio = extractStatistic(statisticAofA[i], iControl.CommonStatisticType.STATISTIC_CPU_INFO_USAGE_RATIO);

28:

  29:             updateChart("gauge_" + cpu_id + "_0", 0, "Usage", cpu_usage_ratio);

  30:             updateChart("gauge_" + cpu_id + "_1", 1, "Speed", cpu_fan_speed);

  31:             updateChart("gauge_" + cpu_id + "_2", 2, "Temp", cpu_temp);

32:

  33:         }

  34:         updateTimestamp(true);

  35:     }

  36: }

37:

  38: private void updateChart(String id, long cpuid, String title, long value)

  39: {

  40:     if (null != webBrowser1.Document)

  41:     {

  42:         String[] args = new String[] { id, cpuid.ToString(), title, value.ToString() };

  43:         webBrowser1.Document.InvokeScript("drawChart", args);

  44:     }

  45: }

Resizing Charts

Resizing the charts in the page was rather trivial. I created another embedded JavaScript function setChartSize() which takes as parameters the chart’s width and height. The next time the drawChart() method is called, it uses these values for the creation of the charts.

   1: private void DoResize()

   2: {

   3:     if (timer1.Enabled)

   4:     {

   5:         // Calculate the new chart sizes;

   6:         long width = webBrowser1.Width;

   7:         long height = webBrowser1.Height;

8:

   9:         long newWidth = ((width) / 3) - 50;

  10:         long newHeight = ((height) / 2) - 20;

11:

  12:         if (newHeight > newWidth) { newHeight = newWidth; }

  13:         if (newWidth > newHeight) { newWidth = newHeight; }

14:

  15:         resizeCharts(newWidth, newHeight);

  16:     }

  17: }

  18: private void resizeCharts(long width, long height)

  19: {

  20:     if (null != webBrowser1.Document)

  21:     {

  22:         String [] args = new String[] { width.ToString(), height.ToString() };

  23:         webBrowser1.Document.InvokeScript("setChartSize", args);

  24:     }

  25: }

Video Walkthrough

CPU Monitoring witht the Google Visualization APIs

Get The Source

The source code for this application can be downloaded from the following link: CPUVisualization.zip

Getting Started With iControl And Java – Setting Up Eclipse

devcentralteam@f5.com (F5 DevCentral Team) — Wed, 15 Sep 2010 17:00:00 GMT

This is the first article in a series focused on developing iControl applications with the Java language. I’ve picked Eclipse development platform for this set of platforms. The goal here is to give you the directions and tools you need to make the most out of iControl when you are involved with Java development.

For this article, I’m going to assume that you are starting off of a clean system. In most cases, you will already have one or more of the prerequisites installed so you can feel free to ignore that section. This article was developed with all the components on a Windows 7 System, but everything should work similarly on other platforms.

The Pieces To The Puzzle

Java

The first item you will need to install is Java itself. This can be downloaded from the Java Website At Oracle.com. There are a lot of different versions of Java but I always stick to the bare bones “Java SE” JDK distribution.

I’m not going to walk through the installation of Java as I assume you can figure that one out for yourself. If you are really stuck, do a Google Search for “How To Install Java” and that should point you in the right direction.

Eclipse

Eclipse is an open source development platform build with extensible frameworks, tools and runtimes for many different languages – Java being one of them. The JDT (Java Development Tools) project provides the tool plug-ins that implement a Java IDE supporting the development of any Java application.

To install Eclipse for Java, visit the downloads page at http://www.eclipse.org/downloads/ and select the appropriate “Eclipse IDE for Java Developers distribution. Even though I am running 64-bit windows, I had an issue getting the 64-bit build of Eclipse to work. This was possibly due to the version of Java I had installed. So, I picked the “Windows 32 Bit” download and it worked out find.

The download is just a .zip file containing the product directory. Just unzip this to a location of your choosing.

iControl Library For Java

At this point you should have a development environment setup for building Java applications. The last piece of the puzzle is the iControl libraries for Java. iControl is a set of Web Services and we have taken the Web Service Description Language (WSDL) files, built client proxy code for them, and packaged them within a nice wrapper class and packed them into a Java library to make it as easy as possible for you to integrate iControl into a new or existing Java application.

To get the libraries, you’ll need to visit the iControl Assembly (we have a .Net version as well) Labs project on DevCentral and click on the “Discussions and Downloads” link. From there Click into the latest release in the “Downloads” section (as of now it is at iControl v10.2) and download the “Java Binary Distribution” release. The “Java Source Distribution” is available if you want to see how I built the library.

The binary download will include two directories: Lib and 3rdparty. The client proxy code was built with Apache Axis so we’ve included those libraries to include in your projects as well so that you don’t have to go hunting elsewhere for all the other dependent libraries. Unzip this directory somewhere on your disk (ie \iControl\javalib).

Building Your First Project

I figured that a video would be easier to follow than me describing the steps it takes to create a project and import the iControl libraries in it so I make this walkthrough where I:

Created a new Java project in Eclipse.
Imported the iControl Library for Java and associated 3rd party libraries.
Created a class with a Main method to be used as a console application.
Created an instance of the iControl.Interfaces object.
Initialized the iControl.Interfaces object with the credentials for my BIG-IP.
Added logic to query the System information and output that to the console.
Debug and demonstrate the application.

I did all that in 5 minutes! …with a little help from cut-and-paste B-).

20100909-GettingStartedWithJava-Eclipse

Conclusion

You should now be able to build a Java application to make use of the automation features of your BIG-IP. In future articles, I will illustrate other aspects of the iControl API with Java.

Download

The Java class for this example can be downloaded from the iControl CodeShare under JavaSystemInfo.

Related Articles on DevCentral

Technorati Tags: iControl, Java, Eclipse, Joe Pruitt

iRule Editor - System Config Editing

devcentralteam@f5.com (F5 DevCentral Team) — Fri, 15 Jan 2010 17:17:00 GMT

In the latest release of the iRule Editor v 0.10.1, I added several new features. This tutorial will walk through System Level Configuration editing allowing you to work with your bigip.conf and bigip_base.conf files without having to open a terminal session to the BIG-IP.

iRule Editor - Offline Editing

devcentralteam@f5.com (F5 DevCentral Team) — Fri, 15 Jan 2010 17:13:00 GMT

In the latest release of the iRule Editor v 0.10.1, I added several new features. This tutorial will walk through the Offline Editing features I've added that allow you to write your iRules when not connected to the BIG-IP. It will also show you how to take your online iRules and move them offline in preparation for a long plane flight or time without network connectivity.

iRule Editor - Auto Connection

devcentralteam@f5.com (F5 DevCentral Team) — Thu, 14 Jan 2010 16:46:00 GMT

In the latest release of the iRule Editor v 0.10.1, I added several new features. This tutorial will walk through the Auto Connection features I've added that allow you to supply command line arguments to have the iRule editor automatically connect to your specified BIG-IP.

Getting Started with pyControl v2: Understanding the TypeFactory

devcentralteam@f5.com (F5 DevCentral Team) — Mon, 14 Dec 2009 22:41:00 GMT

In this video, Matt Cauthorn dives into the importance of the typefactory in pyControl v2.

Getting Started with pyControl v2: Working with Types

devcentralteam@f5.com (F5 DevCentral Team) — Mon, 14 Dec 2009 22:39:00 GMT

In this video, Matt Cauthorn introduces type usage in pyControl v2.

Getting Started with pyControl v2: Installing on Windows

devcentralteam@f5.com (F5 DevCentral Team) — Mon, 14 Dec 2009 18:15:00 GMT

It's true--pyControl v2 is officially out the door! Here are the installation instructions for Windows (captured below on XP Pro but work equally as well on 7 Ultimate.)

Getting Started with pyControl v2: Constructor Changes

devcentralteam@f5.com (F5 DevCentral Team) — Mon, 14 Dec 2009 18:15:00 GMT

Matt Cauthorn walks through the pyControl v2 constructor changes in this video.

Getting Started with pyControl v2: Method Hints via Attributes

devcentralteam@f5.com (F5 DevCentral Team) — Mon, 14 Dec 2009 18:15:00 GMT

In this video, Matt Cauthorn walks through the method hints available via attributes in pyControl v2.

Configuring BIG-IP and Cacti for SNMPv3

devcentralteam@f5.com (F5 DevCentral Team) — Tue, 07 Jul 2009 12:57:00 GMT

In this video tech tip, I'll walk through the configuration steps necessary to enable SNMP version 3 on the BIG-IP and Cacti.

iControl Apps - #19 - Pool Membership Reverse Lookup

devcentralteam@f5.com (F5 DevCentral Team) — Wed, 17 Jun 2009 20:08:00 GMT

Pool's are collections of pool members which are IP address and ports for a specific back end application server. Currently through the iControl API there is no direct way to do a reverse lookup of which pools a specified application server is a member of. This application will, given a pool member specification, do a reverse lookup and list all the associated pools that member is included in.

Cacti: Creating Templates for Indexed SNMP Data

devcentralteam@f5.com (F5 DevCentral Team) — Tue, 16 Jun 2009 21:05:00 GMT

In the last Cacti article, we walked through creating a graph template off individual static oids. This time out, we're going to look at how to build a template with a data query based on indexed SNMP mibs.

v.10 - Remote Authorization via TACACS+

devcentralteam@f5.com (F5 DevCentral Team) — Tue, 02 Jun 2009 20:30:00 GMT

Remote authorization for ldap was first introduced in version 9.4. Now, however, in v10, the feature has been expanded to include radius and tacacs+. In this article, I'll walk through the tacacs+ server configuration and the remoterole configuration on the BIG-IP required to get remote authorization working.

v.10 - BIG-IP Dashboard

devcentralteam@f5.com (F5 DevCentral Team) — Thu, 23 Apr 2009 16:46:00 GMT

In this video walkthrough, I'll give a rundown on the new BIG-IP administrative dashboard that allows dynamic real-time monitoring of system resources and usage.

v.10 - BIG-IP UI Walkthrough

devcentralteam@f5.com (F5 DevCentral Team) — Thu, 16 Apr 2009 20:24:00 GMT

In this video walkthrough, I'll give a rundown on the new BIG-IP User Interface (UI) and highlight some of the cool new features that you may not be aware of.

Cacti: Creating a Graph Template

devcentralteam@f5.com (F5 DevCentral Team) — Thu, 02 Apr 2009 15:23:00 GMT

A while back I wrote an article on Graphing the LTM with Cacti. The article was mostly pointed towards installation and configuring a graph from a pre-configured host template. In this video, I'll show you how to create a graph template to track the WebAccelerator memory and disk hit counts.

pyControl - Installation

devcentralteam@f5.com (F5 DevCentral Team) — Thu, 12 Jun 2008 15:17:00 GMT

In this video tutorial, F5's Matt Cauthorn goes over the installation process required to start using pyControl, the python libraries for iControl DevCentral Labs project.

DevCentral 101 - #05 - CodeShare

devcentralteam@f5.com (F5 DevCentral Team) — Thu, 13 Mar 2008 07:01:00 GMT

In this installment of DevCentral 101, Joe goes over how to post a sample to the CodeShare section of the DevCentral wiki.

DevCentral 101 - #04 - Docs

devcentralteam@f5.com (F5 DevCentral Team) — Wed, 13 Feb 2008 16:35:00 GMT

In this installment of DevCentral 101, Joe goes over the Docs and Tips section on DevCentral.

DevCentral 101 - #03 - Homepage

devcentralteam@f5.com (F5 DevCentral Team) — Tue, 12 Feb 2008 00:28:00 GMT

In this installment of DevCentral 101, Joe highlights all the goodies that can be found on the DevCentral Homepage.

DevCentral 101 - #01 - Registration

devcentralteam@f5.com (F5 DevCentral Team) — Thu, 24 Jan 2008 08:01:00 GMT

In the first installment of this series, Joe goes over the first step in becoming a member of the DevCentral Community - User Registration.

iRule Editor - Admin Partitions

devcentralteam@f5.com (F5 DevCentral Team) — Tue, 11 Sep 2007 21:30:00 GMT

This tutorial illustrates how to use the latest release of the iRules Editor to create, save, and modify iRules stored in multiple. Administrative Partitions. For those who don't know about the partition support added in BIG-IP v9.4, it's basically a way to create "buckets" for configuration objects, each with their own access controls. Partitions make it very easy to segment virtual servers and it's applications to certain business or network groups. This tutorial shows how to use the iRule Editor to create iRules in any partition the logged in user has access to.

Video: Java with the iControl API in Eclipse

devcentralteam@f5.com (F5 DevCentral Team) — Wed, 15 Aug 2007 19:40:00 GMT

Don walks through using iControl in Eclipse. This video assumes that you have already built the iControl JAR file per the instructions in the API documentation, and then shows you the basic steps needed to call routines on the BIG-IP from your Java code.

iRule Editor - Generating Traffic

devcentralteam@f5.com (F5 DevCentral Team) — Wed, 25 Jul 2007 22:41:00 GMT

This tutoral illustrates how to use the Traffic Generation Dialog in the iRule Editor to assist in debugging and testing your iRules. Didn't know that the iRule Editor was a full blown HTTP client? Well, after watching this, you'll be "in the know".

Getting Started with iControl v9 and Visual Studio

devcentralteam@f5.com (F5 DevCentral Team) — Wed, 25 Jul 2007 20:08:00 GMT

Just embarking on your iControl/Visual Studio development project? Then this is the video for you! Joe walks you through the steps to get your iControl application up and running fast using .NET and Web Services.

iControl SDK Walkthrough

devcentralteam@f5.com (F5 DevCentral Team) — Fri, 20 Jul 2007 17:31:00 GMT

The iControl SDK is the definitive guide to building applications to remotely manage your F5 devices. In this video feature, Joe walks through the iControl SDK in it's various forms and gives some insights into how to make sense of it all.

DevCentral 101 - #02 - Labs Intro

devcentralteam@f5.com (F5 DevCentral Team) — Fri, 20 Jul 2007 17:18:00 GMT

In this tutorial, Joe gives a video walkthrough of DevCentral Labs.

PowerShell - Getting Started

devcentralteam@f5.com (F5 DevCentral Team) — Fri, 22 Jun 2007 19:31:00 GMT

In this tutorial, Joe walks through downloading, installing, configuring, and using the iControl PowerShell Snapin. He walks through and demonstrates several of the available CmdLets.

iRule Editor - Sharing iRules

devcentralteam@f5.com (F5 DevCentral Team) — Thu, 19 Apr 2007 07:01:00 GMT

This tutorial walks you through the sharing features built into the iRule Editor. Ever wanted to share your iRule with the world? This is your chance.

iRule Editor - Editing iRules

devcentralteam@f5.com (F5 DevCentral Team) — Tue, 17 Apr 2007 07:01:00 GMT

This tutorial guides you through the editing features of the iRule Editor.

iRule Editor - Deploying iRules

devcentralteam@f5.com (F5 DevCentral Team) — Mon, 16 Apr 2007 07:01:00 GMT

In this tutorial, you will be guided in the process of deploying your iRules. This involves updating them on the server and assigning them as a resource to a virtual server.

iRule Editor - Data Groups

devcentralteam@f5.com (F5 DevCentral Team) — Sun, 15 Apr 2007 07:01:00 GMT

In this tutorial, you will be guided through creating and managing Data Groups from within the iRules Editor.

iRule Editor - Creating iRules

devcentralteam@f5.com (F5 DevCentral Team) — Sat, 14 Apr 2007 07:01:00 GMT

In this tutorial, you will be guided through the process of creating iRules with the iRule Editor.

iRule Editor - Archiving iRules

devcentralteam@f5.com (F5 DevCentral Team) — Fri, 13 Apr 2007 21:43:00 GMT

Everything you wanted to know about Archiving iRules but were afraid to ask...