I looked for a solution to this for awhile but didn’t find anything relating to VuGen and Syntax Highlight things, so I started digging a little deeper into VuGen’s configs and came up with a half-way solution to this.

To start with I discovered that VuGen uses the SlickEdit OEM text editor as the basis for code editing. This in turn lead to looking for .vlx files with the keywords definitions.

I found a file called vugen.vlx that seemed to contain the right data, and lo and behold, changing the file made a difference!

So to add lr_save_float(); as a lr_* syntax highlighted command you should edit the vugen.vlx file found in C:\Program Files\HP\LoadRunner\bin\vslick as follows:

1. Open the file in your favorite (UltraEdit32) text editor
2. Go to the end of the file
3. Add the following line as the last just above last ;// line:
; Added custom LR keywords
userkeywords=lr_save_float

Here’s a snip of how it should look:

...
userkeywords=soa_xml_validate ws_sign_saml_assertion
userkeywords=lr_db_connect lr_db_disconnect lr_db_dataset_action lr_checkpoint lr_db_getvalue lr_db_executeSQLStatement
userkeywords=nca_system_command

; Added custom LR keywords (multiple function names can be separate with space)
userkeywords=lr_save_float lr_replace

;// please save 1 empty line for SDK Protocol merge

And why this is half-way is that I still have to figure out how to change the actual color and assign a different keyword group to my custom commands …

Enjoy!

And as was to be expected it wasn’t a simple click-click-go thing

The steps to install are pretty straight forward. Worth mentioning here is that I installed the FULL package, controller and all. If you install the StandAlone versions, the procedure and problems may be different.

Installing LoadRunner v11

So here are the steps:

1. Install the FULL loadrunner package from the installer (setup.exe)
2. Install the following patches:

• Analysis_lr11_pr_9790 patch. (a zip file that is extracted on top of existing .\bin directory)
• LR_03014 – Patch 03014 (imaginative name as always )
• LR_03017 – Patch 1
• LR_03044 – Patch 2
• LR_03063 – Patch 3 (Adds IE9 support)

The manual work involved when installing the patches is to go and cleanup after the installer. Each time a patch is installed it leave a %EXTRACTPATH% folder under the .\HP\LoadRunner\ directory that contains folders like Bin, Help, Tutorial etc.

After each patch installation you need to go into the %EXTRACTPATH% folder and move all the folders in there to the .\HP\LoadRunner\ directory.

Also for each Patch that I installed I got a couple of errors with Online.exe and a few OCX registration failures. I pressed OK for the dialogs, and the installation continued.

All of this took about 2h to do, and now I have a fully working LoadRunner v11 installation ready to go. If you do not have a license then the controller will work for 10 days.

A note for Win7 users

When starting your controller you might receive a “Cannot initialize driver dll, Exiting …” message. If you do the remedy is to run the application (controller) as Administrator (right click icon and choose Run As Administrator).

Downloading the patches from HP

To download the patches from the HP support site you can use the following URL as a template:

http://support.openview.hp.com/downloadAPatch.jsp?patchName=LR_03063.EXE&prodName=lr&prodRelease=11.00

See the red underlined part? Replace with the proper LR patch name to download…

Enjoy!

During these two weeks there has been some more information released to the public, both from the vendor (Accenture), the customer (VR) and the hosting company Tieto.

Among the more interesting ones:

• The system was tested by the vendor in India. (Link)
• Tickets have been “lost” and not delivered even when money has been charged (Link)

Lets consider the first one

What’s wrong with that first one? In my opinion the VENDOR of the software must never ever, under any circumstances, be allowed to do the final testing of the software. If I where in the paying customers shoes, I would not be able to trust the vendor to do proper testing, and even if I demanded test results I would consider them even less trustworthy than the testing itself.

The fact it was tested in India means nothing in itself. The people over there are as competent as anywhere. The problem is that they are working for the vendor.

In reality the business is usually setup so that the project is budgeted beforehand, and the sales agreement probably does not include testing with more than a few words, nor much about the fixing of defects. And to top off the weird things: In some cases if the vendor makes the deal and the vendors sales people get their bonuses even before the actual system is even created, installed, or tested.

After the deal is made, a different group of people actually start to design, code and build the final system. It is often also this same group of people that are later charged with the testing of the software. The project has a “test group” to test what the “development group” have produced, and all this managed under the same “project”, and the same people responsible in the end.

The project is most probably bound by release deadlines. And remember that the bonuses are also tied to these deadlines. I do not think the project lead wants to delay the project release dates just because of a few bugs? Very often then thinking is: “We can put them on the defects list and schedule to fix them later. The important thing is to get a release done before the deadline so we get our bonuses.”

I would say that the focus and goal the the project is a little skewed here?

Also considering that a separate agreement is often in place, stating that “bugs” and “issues” in the delivered system are taken care of in the next release. Of course this “maintenance release” or “update release” is not free of charge! This setup is perhaps the most ideal setup ever to produce the worst quality software ever. In every place the focus is on the wrong thing.

How should they have done the testing then?

This is a hard question, and often both the customer and the vendor are reluctant to admit that testing is costly and takes a lot of time. Proper testing may also delay the release dates and in the worst case cause serious redesign of the whole system.

In truth, even proper testing will never be able to save a badly designed, ill implemented system after it has been done.

Proper testing however CAN prevent a bad design and prevent ill implementation.

In this specific case I would have, from the Customer side, chosen to buy the quality assurance as a whole from a third party that specializes in quality assurance. There are several of these companies around, and they have nothing to GAIN nor LOSE by doing proper testing.

The testing team (QA) should be separated from the development team (vendor) in regards to money. This will ensure that the QA team has no problem with reporting the errors they find. It should also make the developers want to produce better quality since they now have an independent testing authority. Side note: Never tie the QA teams money to the number of defects either!

And as this was a large project I would suggest several experienced quality guys (Functional, Automated and Performance) to work WITH the developers during the development, to prevent the bad designs and ill implementations before they are even done.

And what about the second point (remeber, up there the two bullet points)?

In addition to all the above there has been discovered a serious bug in the way the system handles payments and tickets.

It seems there have been several (read hundreds) of cases where people have been charged for a ticket, but have never received the ticket! I even heard about a mom that bought a family ticket twice, and was promptly charged and never received either of the tickets.

VR officially says that to get a refund for a “lost” ticket: “You must call our non-free customer service, queue for your turn and then we’ll look into it”.

Say what? Call a customer service number that COSTS you even MORE money than you have already lost, not counting the TIME spent on this, and the frustration?? Just gobsmacking how they treat their customers!

The system was thoroughly tested according to the vendors spokespersons. So what did they really test? And How? These are questions we may never get answers to, but we sure do know the results of the testing

What are the effects of all of this?

Now what are the effects of all of this, besides the obvious vendor PR?

There have been reports of the people in the customer service department of VR saying that they want more money because of the increased workload. Not to mention they have to listen to all the people calling in and shouting at them for a failed system! The customer service people are definitely not to blame for all of this.

I say that brave souls sit there and answer the phone these days.

VR’s reputation has been tarnished for a long time by this. They have never been very good at keeping the timetables, especially during winter with the French train carts, but this new scandal with the tickets really puts them in a bad light. This ultimately leads to less people using the trains, meaning less money for VR, leading to higher ticket prices …

So, from all the people who use the trains daily: Thank You for a well managed project, well built and well tested system. (NOOOT)

PS.

Did you know that a one-time 1h ticket costs 4€ in Helsinki. This gives you the option to travel with Bus, Train or Tram inside Helsinki, Espoo and Vantaa areas for free for 1h after the purchase of the ticket.

If I drive my car to the center of Helsinki an park it for 8h (workday) I pay 8€ (1€/hour).

So, WTF? 2 times 4€ with commuter traffic is THE SAME PRICE as parking my car for 8h? Which one do you think I choose to use, especially with the problems of late!

Today there’s been big news-flashes on several Finnish news sites about the local train monopoly firm and their new web-based ticket sales system crashing under a heavy load. They had introduced a new online ticket sales system, and where literally overrun. The official comment from the company was (translated) “we where surprised to see such traffic amounts”.

Two of the articles: here, and here

A very welcome small detail in the official apology about the crashing system:

“The new ticket system got a 20 times higher than usual rate of sales, resulting in some 800 clicks per second” 

They also said that it was fixed 2 hours later by adding more hardware, but at 10pm (~12 hours later) I still wait for 1m 16s (according to firebug) to load the page, something I think is WAY too slow.

Assuming a click is a page-load, it would mean that 800 page loads/sec x (1+68) page+resources = 54 400 HITS/SEC !! I think not.

What they probably mean is 800 HITS/sec, and that would make roughly 800/68 = 11 page loads/second. But Wait a minute, Only 11??

As I have no idea of how the system is built, other than it’s running on NGIX web-servers, I can’t comment on how fast/slow it should be, but from my experience 11 page loads per sec seems to be a little low. Also if 11 page-loads/sec was peak traffic at 20 times the normal, it means the Normal traffic is only 11/20 = 0.55 page-loads/sec (37 hits/sec).

EDIT:  Got more info on the sales figures. They have sold 10K tickets/day (peak), where normally selling around 5000/day.

Calculating Tickets per sec:  10K/day = 416/h = 7/m = 0.11/sec

My conclusions about all of this

So my conclusion is that the system was probably more or less built according to specs given, specs that most probably lacked any performance requirements in any meaningful way. The reason for the Perf reqs missing is most probably inexperience on the part of the people who wrote the specs, specifically of what performance is and what it really means. I’ve seen this in almost all the new projects I’ve been involved in.

I also suspect that proper performance testing of the system has not been done.

In another news-article I read that the system has been developed for 2 years, and during that time there should have been plenty of time to performance-, stress- and load -test the system. Fix the problems and retest again until it reaches a performance that is acceptable.

Estimating the Expected Load

The following calculations are based on rough guesses on my part.

As a base rule of thumb I usually use the following formulas for estimating pages/sec (when it’s a public web site, or the interface is used by the public (pay booths etc.)):

Average Concurrent Users (ACU) = Total Expected User Base (all potential users) * 1%

Average Concurrent Pages (ACP) = ACU * 1%

So I can only speculate, but in Finland we have 5.3 Million people, of which 15-65 year old people are ~3.5million, of which 1% is 35000 potential concurrent people wanting to buy tickets. I assume that about 1/3 of these people would use the trains and about 1/3 would by tickets online (there are about 2 million privately registered vehicles in Finland).

So ACU becomes 3.5Million*0.01 = 35000*0.33*0.33 = ~3811

ACP then becomes 3811*0.01 =~38 pages/sec. (1% of online users are there clicking at the same time)

These numbers may seem high to some, but remember the potential user base really is 3.5 million users.

In comparison, using 0.55 pages/sec would give us: 0.55/0.01 = 55/0.33/0.33 = 505/0.01 = ~50505.

My way of estimating the average load probably gives a little higher result than theirs .. but remember, it’s just estimations …

So how much more should the system be able to handle at peak hour? This is a really difficult question and is totally dependent on the system and how it’s used. I estimate that the an online train-ticket system should be able to withstand a 30 fold short time peak, since some seasonal tickets come on sale on specific dates (We now know that the actual peak load was at least 20 times, and the system crashed after that).

So my estimation would be (worst case scenarios):

Avg load = ~38 pages/sec

Peak load = ~1140 pages/sec

And the Solution?

The only real solution to this is to get specialized  professional help from the real pros. People like architects, performance testers, and test managers, who know what they are doing. It may be more costly than doing it in-house or with a larger consultant vendor, but if and when the results of a go-live launch are as described above, I think the money spent on pro’s would have been far less than the money now needed to roll back to the old system in production, retest the new system in QA, find and fix the issues, and perhaps even redesign parts or all of how it works internally.

At the very minimum the people doing the specs should get the pros to help out during the specification phase.

And where to get the professional help? Especially f the large consultant vendors don’t seem to be able to provide?

Answer: Find smaller specialized consultant companies that are experts in the field – My company Celarius is one such company

If you read this far, then perhaps you would like to comment:  How would YOU have estimated the load?

Beeing a person who believes software should work in diverse environments, I also tried installing LoadRunner on the Win 7 machine, specifically Analysis and VuGen as I do scripting with the laptop, no controller was needed. So I set out to install it and also did a few tricks on the way, things I knew would not work or had to be changed.

In short the following actions where taken during installation:

• Install v9.50  into C:\USERS\[Username]\HP instead of standard Program Files directory
• This because VuGen writes to INI files etc. all the time it needs write access to the install folder
• Install v9.51 upgrade patch
• After v9.51 upgrade patch, modify registry as per Richard Bishops blog entry Installing LoadRunner on 64 bit Windows
• In addition to Bishops instructions:
• Make sure the“HKLM\Software\WOW6432Node\Mercury interactive” key is NOT MOVED but COPIED to the “HKLM\Software\Mercury Interactive” key !! If moved v9.52 patching won’t work as it checks BOTH keys for the existence of v9.51!
• Also make sure the values in both keys “…\Mercury Interactive\LoadRunner\CurrentVersion” are as follows:
• DisplayName = “HP LoadRunner Software 9.51″
• Minor = “51″
• Install v9.52 upgrade patch
• Install IE8 upgrade Patch
• When starting VuGen it complained about the WebAEDUI.DLL. I replaced this with another older version of the DLL from v9.51 .. And the complaints where gone!

At this point to Analysis worked 100%, and VuGen worked all the way to the point where a web function was called. The call itself worked, and the result was retrieved but alas, the HTML parser failed with a critical exception error. So still I had not achieved 100% VuGen, but I was able to record, and replay non-html pages fine.

Now last Tuesday, Microsoft released a massive patch pack (some 29 fixes I think it was) and just by accident I was demonstrating Analysis and VuGen to a friend – and TO MY GREAT SURPRISE VuGen now replayed and parsed text/html content 100% ! So now I have myself a fully working LR v9.52 installation, and no longer see any immediate need to upgrade to the new ALM v11 just because people switch to Win 7.

EDIT:

After having tried installing VuGen on other Win7 machines, both x32 and x64 I’ve experienced that the Reply still does not work as it should, and fails with an Exception. I think the problem is related somehow with the registration of the “RTBComm.dll” and “LrwRTBSyncObject.DLL” components.

In the original installation also had these problems, but as the patch-set from Microsoft was applied it apparently fixed this registration issue.. So now I’m still not able to get it working on most machines. Only one other Win7 x32 has gotten it working so far (was not done by me)..

If you people out there get it working, please let me know HOW it was done and WHAT was done to make it work! Thank You!

Enjoy!

I had a situation where I had a pre-made script that had fixed think-time values for the lr_think_time() calls, and they of course were completely wrong. So my problem was that I had a lot of lr_think_time() places and I didn’t want to go through them all myself.

In most cases a search-and-replace would do the trick, but I stumbled upon the overriding of functions and implemented it that way instead, making my changes to the script stay in one place only instead of manipulating all the actions in the script.

Remember: DO NOT CALL THE OVERRIDDEN FUNCTION INSIDE THE NEW CODE!!! – You’ll just end up with an endless loop, and terminate in stack-errors or similar…

Here’s an empty script where I’ve overridden the lr_think_time() function with a custom one:

#define lr_think_time my_think_time  // This define overrides lr_think_time() with my_think_time()

double my_think_time(double sec)
// This simulates the 50% to 150% think-time randomness ...
{
	double x;

	x = ((50.0+rand()%100)/100)*sec; // 50% to 150% randomness

	lr_force_think_time( x ); // force the think time (this is undocumented command)

	return x; // return how many seconds we waited
}

///////////////////////////////////////////////////////////////////////////////

Action()
{
	lr_think_time(10); // This will use the my_think_time() function !!

	return 0;
}

One could get creative and start overriding all sorts of functions with this. An example would be to set specific headers for specific web_url() calls depending on the params. You could override the web_url() call, examine the parameters and add any needed HTTP headers before doing a web_custom_request() instead ..

Enjoy!

The DLL I’ll create here is a simple stub with a few basic functions and can serve as a template for any type of DLL that you want to create.

I’ll show how to avoid the most common problems of sending/retrieving strings to/from the DLL as well as how to handle the Unicode situation with D2009 and D2010 (LR is not Unicode enabled).

Some of the things a LR DLL developer needs to remember are:

• LR is Muti-Threaded and Multi-processed, make the DLL thread-safe
• When using LoadGenerators the DLL must be distributed to several machines
• When using Performance Center the lr_load_dll() function needs to be white-listed on every LoadGenerator. The file to manipulate is “C:\Program Files\HP\Load Generator\merc_asl\lrun_api.asl”
• The DLL may be unloaded at any time, if the script fails/aborts (=> YOU must release allocated memory)
• If eternal loops or lockups inside the DLL occur, the whole controller/loadgenerator is lost until rebooted (really bad when under PerfCenter)

Keeping the above in mind, also remember the following general rules

• LR script makers make mistakes too by sending INVALID input to functions or using them in an unintended way. This means that you as a DLL developer NEED TO VERIFY the input params for every function call!
• The DLL may be installed on a variety of windows platforms (Win2000->Win7) so make sure you check the OS Version if you are using Windows API calls that are version dependent
• There is no guarantee that the DLL has Administrator privilidges!
• The DLL is restricted to the same Win32 memory as the host process (2 Gig max allocation)

Creating the DLL in Delphi

Close all projects and then choose “FILE | OTHER …“, select “DELPHI PROJECTS” and then “Dynamic Link Library“. You should now have the following skeleton (excluding all comments):

  library Project1;

  uses
    SysUtils,
    Classes;

  {$R *.res}

  begin
  end.

Now copy & paste the following instead of the above:

library MyDLL;

uses
  SysUtils, Classes, Windows,
  VUManager in 'VUManager.pas';

Const
  { Version Constants }
  DLLVer_Major                 = 1;
  DLLVer_Minor                 = 0;
  DLLVer_Copyright             = 'Copyright (C) by Celarius Oy';

  { DLL Errors - Negatives are errors }
  ERR_None                     =  0;
  ERR_Unknown                  = -1;
  ERR_Unknown_Object           = -2;
  ERR_Insufficient_Buffer      = -3;

////////////////////////////////////////////////////////////////////////////////

Var
  VUMgr : TVUManager;

{$R *.res}

////////////////////////////////////////////////////////////////////////////////

function dll_Initialize( VUserID: Cardinal ): Integer; stdcall;
// Initialize DLL, Adds the Vuser with the ID
//
// Returns
//    Integer    The Error code
begin
     If VUMgr.AddVUser( VUserID ) then
        Result := ERR_None
     Else
        Result := ERR_Unknown_Object;
end;

////////////////////////////////////////////////////////////////////////////////

function dll_Finalize( VUserID: Cardinal ): Integer; stdcall;
// Finalize DLL, removes the VUser with the ID
//
// Returns
//    Integer    Error code
begin
     If VUMgr.RemoveVUser( VUserID ) then
        Result := ERR_None
     Else
        Result := ERR_Unknown_Object;
end;

////////////////////////////////////////////////////////////////////////////////

function dll_GetVersion: Integer; stdcall;
// Get Library version
//
// Returns
//    Integer    Version Number
begin
     Result := (DLLVer_Major SHL 16) + DLLVer_Minor;
end;

////////////////////////////////////////////////////////////////////////////////

function dll_GetCopyright( DestStr: PAnsiChar; DestSize: Integer): Integer; stdcall;
// Get Library Copyright String
//
// Returns
//    Integer    Version Number
begin
     if (DestSize>Length(DLLVer_Copyright)) then
     Begin
          StrCopy( DestStr, PAnsiChar(DLLVer_Copyright) );
          Result := ERR_None;
     End Else Result := ERR_Insufficient_Buffer;
end;

////////////////////////////////////////////////////////////////////////////////

function dll_TrimStr(ID:Cardinal; SourceStr: PAnsiChar; DestStr: PAnsiChar; DestSize: Integer): Integer; stdcall;
// Trims a String (removes special chars in beginning/end)
//
// Returns
//    Integer    Error Code
Var
   VU : TVirtualUser;
   S  : AnsiString;
begin
     { Find the Virtual User }
     VU := VUMgr.FindVU(ID);
     if Assigned(VU) then
     Begin
          S := VU.TrimString( SourceStr ); // process the string

          if (DestSize>Length(S)) then
          Begin
               StrCopy( DestStr, PAnsiChar(S) );
               Result := ERR_None;
          End Else Result := ERR_Insufficient_Buffer;

     End Else Result := ERR_Unknown_Object;
end;

////////////////////////////////////////////////////////////////////////////////

{ Export functions }
exports
  { General Functions }
  dll_Initialize       name 'dll_Initialize',
  dll_Finalize         name 'dll_Finalize',
  dll_GetVersion       name 'dll_GetVersion',
  dll_GetCopyright     name 'dll_GetCopyright',
  dll_TrimStr          name 'dll_TrimStr'
  ;

////////////////////////////////////////////////////////////////////////////////

procedure DLLEntryProc(EntryCode: integer);
//
// DLL Entry/Exit, Process and Thread Attach/Detach procedures }
//
Var
   Buf           : Array[0..MAX_PATH] of Char;
   LoaderProcess : String;
   DLLPath       : String;
begin
     Try
        Case EntryCode of
             { The DLL has just been loaded with LoadLibrary()               }
             { either by the main process, or by a vuser - we do not know    }
             { which one                                                     }
             DLL_PROCESS_ATTACH:
             Begin
                  { Get the Path where the DLL is }
                  GetModuleFileName(HInstance, buf, Length(buf)) ;
                  DLLPath := ExtractFilePath(StrPas(buf));
                  { Get the name of the module that loaded us }
                  GetModuleFileName(HInstance, buf, Length(buf)) ;
                  LoaderProcess := StrPas(buf);
                  { Create handler }
                  VUMgr:= TVUManager.Create( NIL );
             End;

             { The Process Detached the DLL - Once per MMDRV Process }
             { Application called Unload - Perform Cleanup }
             DLL_PROCESS_DETACH:
             Begin
                  If Assigned(VUMgr) then FreeAndNil(VUMgr);
             End;

             { A Thread has just loaded the DLL }
             DLL_THREAD_ATTACH:
             Begin
                  { This occures when a VUser calls lr_load_dll() }
             End;

             { A Thread has just unloaded the DLL }
             DLL_THREAD_DETACH:
             Begin
                  { This occures when a VUser exits }
             End;
        End;
     Except
        // TODO: Write an Exception Handler
        On E: Exception do ;
     End;
end;

////////////////////////////////////////////////////////////////////////////////
//
// DLL Initialization - When DLL is loaded the first time by any process }
//
////////////////////////////////////////////////////////////////////////////////
begin
{$IFDEF Debug}
          { True means Delphi checks & reports memleaks }
          ReportMemoryLeaksOnShutdown := True;
{$ENDIF}
          { Make the Memory-Manager aware that this DLL is used in Thread-environments }
          IsMultiThread := True;
          VUMgr:= NIL;

          { If we have not already set te DLLProc, do it }
          if NOT Assigned(DllProc) then
          begin
               DLLProc := @DLLEntryProc;         // install custom exit procedure
               DLLEntryProc(DLL_PROCESS_ATTACH);
          end;
end.

You can now save the project as “MyDLL” in a folder of your choice.

Now we’ll need to create the VUManager unit with “FILE | NEW UNIT” and save the new unit as “VUManager.pas” in the same directory as the rest of the Delphi files. Copy & Paste the following into the new unit.

unit VUManager;

Interface

Uses SysUtils, Classes, Windows;

Type
  { Forward Declarations }
  TVirtualUser = class;
  TVUManager = class;

////////////////////////////////////////////////////////////////////////////////

  TVirtualUser = class(TComponent)
  private
    { Private declarations }
  protected
    { Protected declarations }
  public
    { Public declarations }
    VUserID               : Cardinal;
    Constructor Create(AOwner:TComponent; ID:Cardinal); ReIntroduce;
    Destructor Destroy; Override;
    Function TrimString(InStr: AnsiString): AnsiString;
  end;

////////////////////////////////////////////////////////////////////////////////

  TVUManager = class(TComponent)
  private
    { Private declarations }
    fVirtualUsers          : TThreadList;
  protected
    { Protected declarations }
  public
    { Public declarations }
    Constructor Create(AOwner:TComponent); Override;
    Destructor Destroy; Override;
    { Methods }
    Function FindVU(ID:Cardinal):TVirtualUser;
    Function AddVUser(ID: Cardinal): Boolean;
    Function RemoveVUser(ID: Cardinal): Boolean;
  end;

////////////////////////////////////////////////////////////////////////////////

Implementation

////////////////////////////////////////////////////////////////////////////////

{ TVirtualUser }

constructor TVirtualUser.Create(AOwner: TComponent; ID:Cardinal);
begin
     inherited Create(AOwner);
     VUserID := ID;
end;

destructor TVirtualUser.Destroy;
begin
     Try
        { Cleanup anything that is allocated by the VUser }
     Finally
        inherited;
     End;
end;

function TVirtualUser.TrimString(InStr: AnsiString): AnsiString;
begin
     Result := Trim(InStr);
end;

////////////////////////////////////////////////////////////////////////////////

{ TVUManager }

constructor TVUManager.Create(AOwner: TComponent);
begin
     Try
        inherited;
        fVirtualUsers  := TThreadList.Create();
     Finally
     End;
end;

destructor TVUManager.Destroy;
Var
   I : Integer;
begin
     Try
        { Clear and Free the VUsers List }
        If Assigned(fVirtualUsers) then
        Begin
             With fVirtualUsers.LockList do
             Try
                for I := 0 to Count - 1 do
                    TVirtualUser(Items[I]).Free;
                Clear;
             Finally
                fVirtualUsers.UnLockList;
             End;
             FreeAndNil(fVirtualUsers);
        End;
     Finally
        inherited;
     End;
end;

function TVUManager.FindVU(ID: Cardinal): TVirtualUser;
Var
   I : Cardinal;
begin
     Result := NIL;
     With fVirtualUsers.LockList do
     Try
        for I := 0 to Count - 1 do
        Begin
             if TVirtualUser(Items[I]).VUserID=ID then
             Begin
                  Result := TVirtualUser(Items[I]);
                  Break;
             End;
        End;
     Finally
        fVirtualUsers.UnlockList;
     End;
end;

function TVUManager.AddVUser(ID: Cardinal): Boolean;
Var
   VU : TVirtualUser;
begin
     Result := False;
     With fVirtualUsers.LockList do
     Try
        VU := TVirtualUser.Create(NIL, ID);
        Add( VU );
        Result := True;
     Finally
        fVirtualUsers.UnlockList;
     End;end;

function TVUManager.RemoveVUser(ID: Cardinal): Boolean;
Var
   I : Cardinal;
   VU : TVirtualUser;
begin
     Result := False;
     With fVirtualUsers.LockList do
     Try
        VU := NIL;
        for I := 0 to Count - 1 do
            if TVirtualUser(Items[I]).VUserID = ID then
            Begin
                 VU := TVirtualUser(Items[I]);
                 Delete(I);
                 Break;
            End;
     Finally
        fVirtualUsers.UnlockList;
        if Assigned(VU) then
        Begin
             FreeAndNil(VU);
             Result := True;
        End;
     End;
end;

// END OF SOURCE
End.

An short explanation of what’s going on …

The main project file contains the functions that are exported by the DLL. These are available to the LR script. These in turn call methods from the VUManager object where the actual magic of the DLL will happen.

The VUManager has several useful methods (Find/Add/Remove vuser) and then the TVirtualUser object contains the actual methods that perform VUser specific stuff. To extend the DLL one can add methods to the TVirtualUser object and create a small Export interface in the main project file for the method (see the dll_TrimStr() for more details).

The dll_GetVersion() and dll_GetCopyright() functions are there only to provide the script with details of the DLL, and are not mandatory to use when a script uses the DLL.

The dll_Initialize() function

This function is responsible for allocating an instance of a VUser in the VUManager object. It accepts the VUserID that is a unique identifier across all running vusers in a test.

The dll_Finalize() function

The finalize function deallocates (or frees) the VUser instance in the VUManager object. It accepts the VUserID. After this call any dll functions that depend on a valid VUserID will fail with the corresponding error code.

The dll_TrimStr() function

The TrimStr function demonstrates how to “read” a string sent from LoadRunner, manipulate it and then return it to LoadRunner. The PAnsiChar is important here to make Delphi handle the string as an 8-bit null-terminated string, instead of a Unicode string.

How LoadRunner uses the DLL (in theory)

As soon as the MMDRV.EXE process loads the DLL, the DLL creates the VUManager object. This object is responsible for “Managing” the actual VUsers we are going to be servicing. Each VUser Thread also “loads” the DLL but in reality it only gets a copy of it in memory (this is not 100% accurate but good enough for now).

The actual LR script then uses the dll_Initialize(VUserID) function to initialize a VUser in the VUManager, that will allocate an TVirtualUser object for it, with the given ID. This way we can “keep track” of the individual VUsers later when needed. The dll_TrimStr() function takes the ID as the first parameter to identify the VUser.

A LoadRunner script using the DLL

The vuser_init() action:

int VuserID; // Script Global Variable
vuser_init()
{
	int ret;

	// Get VUserID (Needs to be created as parameter)
    VUserID = atoi(lr_eval_string("{VUserID"));

	// Load the DLL
    ret = lr_load_dll("MyDLL.dll");
	if (!ret==0)
	{
		lr_error_message("Could not load DLL");
		lr_abort;
	}

	// Initialize the VUser object inside the DLL
    dll_Initialize( VUserID );

	return 0;
}

The Action() action:

Action()
{
	char buf[1024];

	// Trim a string
	dll_TrimStr( VUserID, "  this string will be trimmed!!  ", buf, sizeof(buf) );

	lr_output_message("Trimmed String='%s'", buf);

	return 0;
}

The vuser_end() action:

vuser_end()
{
	// Finalize the VUser (free the VUser object inside the DLL)
    dll_Finalize( VUserID );

	return 0;
}

I hope this brief introduction to DLL writing for LoadRunner is of help to those who seek information regarding this subject.

Enjoy!

I’ve solved this problem by handling the re-directions myself in-script by doing a DO WHILE loop that keeps running till the end of re-directions, or error for that matter.

Here’s the code for a simple redirection loop (tries to go to mercury.com, but gets re-directed to hp.com instead):

Action()
{
	int HttpRetCode=0;

	// Set redirection depth to 0
	web_set_option("MaxRedirectionDepth", "0", LAST);

	// Initial Location where we want to go
	lr_save_string("http://www.mercury.com", "Location");

	do
	{
		// Save new Redirection Info (Location: header)
		web_reg_save_param("Location",
						   "LB=Location: ",
						   "RB=\r\n",
						   "Ord=1",
						   "NotFound=Warning",
						   "Search=Headers",
						   LAST );

		// do any web call (This needs to be modified to suit your needs)
		web_url("my_req",
		  "URL={Location}",
		  LAST );

		// Get HTTP response Code
		HttpRetCode = web_get_int_property(HTTP_INFO_RETURN_CODE);

	} while ((HttpRetCode>=300) & (HttpRetCode<400));

	return 0;
}

As it turns out a suitable source was found and I made the necessary changes to the code to make it work in LoadRunner. A big thank you to Paul E. Jones for providing a free SHA1 implementation.

I created an include file names “lr_sha1.c” that can easily be included in any C based LoadRunner script or VUser type.

Example of usage (vuser_init.c):

#include "lr_sha1.c"
vuser_init()
{
	//
	// HASH the string "The quick brown fox jumps over the lazy dog",
	// The result should be "2FD4E1C67A2D28FCED849EE1BB76E7391B93EB12"
	//
	sha1_hash("The quick brown fox jumps over the lazy dog", "_sha1");

	lr_output_message( "SHA1 Hash: %s", lr_eval_string("{_sha1}") );

	return 0;
}

And here is the lr_sha1.c file:

/*
 *****************************************************************************
 *
 *  March 2010
 *
 *    Small changes by Kim Sandell to make the source work in LoadRunner
 *    - Changed "const unsigned char" to "const char" in function params
 *    - Combined sha1.h and sha1.c into one file (for ease of use in LR)
 *    - Added sha1_hash() function to ease use in LR
 *    - Included Paul's license in comments
 *
 *****************************************************************************
 *
 *  Freeware Public License (FPL)
 *
 *  This software is licensed as "freeware."  Permission to distribute
 *  this software in source and binary forms, including incorporation
 *  into other products, is hereby granted without a fee.  THIS SOFTWARE
 *  IS PROVIDED 'AS IS' AND WITHOUT ANY EXPRESSED OR IMPLIED WARRANTIES,
 *  INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
 *  AND FITNESS FOR A PARTICULAR PURPOSE.  THE AUTHOR SHALL NOT BE HELD
 *  LIABLE FOR ANY DAMAGES RESULTING FROM THE USE OF THIS SOFTWARE, EITHER
 *  DIRECTLY OR INDIRECTLY, INCLUDING, BUT NOT LIMITED TO, LOSS OF DATA
 *  OR DATA BEING RENDERED INACCURATE.
 *
 *****************************************************************************
 *
 *  sha1.h
 *
 *  Copyright (C) 1998, 2009
 *  Paul E. Jones <paulej@packetizer.com>
 *  All Rights Reserved
 *
 *****************************************************************************
 *  $Id: sha1.h 12 2009-06-22 19:34:25Z paulej $
 *****************************************************************************
 *
 *  Description:
 *      This class implements the Secure Hashing Standard as defined
 *      in FIPS PUB 180-1 published April 17, 1995.
 *
 *      Many of the variable names in the SHA1Context, especially the
 *      single character names, were used because those were the names
 *      used in the publication.
 *
*/

#ifndef _SHA1_H_
#define _SHA1_H_

/*
 *  This structure will hold context information for the hashing
 *  operation
 */
typedef struct SHA1Context
{
 unsigned Message_Digest[5];       /* Message Digest (output)          */
 unsigned Length_Low;              /* Message length in bits           */
 unsigned Length_High;             /* Message length in bits           */
 unsigned char Message_Block[64];  /* 512-bit message blocks      */
 int Message_Block_Index;          /* Index into message block array   */
 int Computed;                     /* Is the digest computed?          */
 int Corrupted;                    /* Is the message digest corruped?  */
} SHA1Context;

/*
 *  Function Prototypes
 */
void SHA1Reset(SHA1Context *);
int SHA1Result(SHA1Context *);
void SHA1Input( SHA1Context *,
 const char *,
 unsigned);
#endif

/*
 *****************************************************************************
 *
 *  sha1.c
 *
 *  Copyright (C) 1998, 2009
 *  Paul E. Jones <paulej@packetizer.com>
 *  All Rights Reserved
 *
 *****************************************************************************
 *  $Id: sha1.c 12 2009-06-22 19:34:25Z paulej $
 *****************************************************************************
 *
 *  Description:
 *      This file implements the Secure Hashing Standard as defined
 *      in FIPS PUB 180-1 published April 17, 1995.
 *
 *      The Secure Hashing Standard, which uses the Secure Hashing
 *      Algorithm (SHA), produces a 160-bit message digest for a
 *      given data stream.  In theory, it is highly improbable that
 *      two messages will produce the same message digest.  Therefore,
 *      this algorithm can serve as a means of providing a "fingerprint"
 *      for a message.
 *
 *  Portability Issues:
 *      SHA-1 is defined in terms of 32-bit "words".  This code was
 *      written with the expectation that the processor has at least
 *      a 32-bit machine word size.  If the machine word size is larger,
 *      the code should still function properly.  One caveat to that
 *      is that the input functions taking characters and character
 *      arrays assume that only 8 bits of information are stored in each
 *      character.
 *
 *  Caveats:
 *      SHA-1 is designed to work with messages less than 2^64 bits
 *      long. Although SHA-1 allows a message digest to be generated for
 *      messages of any number of bits less than 2^64, this
 *      implementation only works with messages with a length that is a
 *      multiple of the size of an 8-bit character.
 *
 *****************************************************************************
 */

/*
 *  Define the circular shift macro
 */
#define SHA1CircularShift(bits,word) \
 ((((word) << (bits)) & 0xFFFFFFFF) | \
 ((word) >> (32-(bits))))

/* Function prototypes */
void SHA1ProcessMessageBlock(SHA1Context *);
void SHA1PadMessage(SHA1Context *);

/*
 *  SHA1Reset
 *
 *  Description:
 *      This function will initialize the SHA1Context in preparation
 *      for computing a new message digest.
 *
 *  Parameters:
 *      context: [in/out]
 *          The context to reset.
 *
 *  Returns:
 *      Nothing.
 *
 *  Comments:
 *
 */
void SHA1Reset(SHA1Context *context)
{
 context->Length_Low             = 0;
 context->Length_High            = 0;
 context->Message_Block_Index    = 0;

 context->Message_Digest[0]      = 0x67452301;
 context->Message_Digest[1]      = 0xEFCDAB89;
 context->Message_Digest[2]      = 0x98BADCFE;
 context->Message_Digest[3]      = 0x10325476;
 context->Message_Digest[4]      = 0xC3D2E1F0;

 context->Computed   = 0;
 context->Corrupted  = 0;
}

/*
 *  SHA1Result
 *
 *  Description:
 *      This function will return the 160-bit message digest into the
 *      Message_Digest array within the SHA1Context provided
 *
 *  Parameters:
 *      context: [in/out]
 *          The context to use to calculate the SHA-1 hash.
 *
 *  Returns:
 *      1 if successful, 0 if it failed.
 *
 *  Comments:
 *
 */
int SHA1Result(SHA1Context *context)
{

 if (context->Corrupted)
 {
 return 0;
 }

 if (!context->Computed)
 {
 SHA1PadMessage(context);
 context->Computed = 1;
 }

 return 1;
}

/*
 *  SHA1Input
 *
 *  Description:
 *      This function accepts an array of octets as the next portion of
 *      the message.
 *
 *  Parameters:
 *      context: [in/out]
 *          The SHA-1 context to update
 *      message_array: [in]
 *          An array of characters representing the next portion of the
 *          message.
 *      length: [in]
 *          The length of the message in message_array
 *
 *  Returns:
 *      Nothing.
 *
 *  Comments:
 *
 */
void SHA1Input(     SHA1Context  *context,
 const char   *message_array,
 unsigned     length)
{
 if (!length)
 {
 return;
 }

 if (context->Computed || context->Corrupted)
 {
 context->Corrupted = 1;
 return;
 }

 while(length-- && !context->Corrupted)
 {
 context->Message_Block[context->Message_Block_Index++] =
 (*message_array & 0xFF);

 context->Length_Low += 8;
 /* Force it to 32 bits */
 context->Length_Low &= 0xFFFFFFFF;
 if (context->Length_Low == 0)
 {
 context->Length_High++;
 /* Force it to 32 bits */
 context->Length_High &= 0xFFFFFFFF;
 if (context->Length_High == 0)
 {
 /* Message is too long */
 context->Corrupted = 1;
 }
 }

 if (context->Message_Block_Index == 64)
 {
 SHA1ProcessMessageBlock(context);
 }

 message_array++;
 }
}

/*
 *  SHA1ProcessMessageBlock
 *
 *  Description:
 *      This function will process the next 512 bits of the message
 *      stored in the Message_Block array.
 *
 *  Parameters:
 *      None.
 *
 *  Returns:
 *      Nothing.
 *
 *  Comments:
 *      Many of the variable names in the SHAContext, especially the
 *      single character names, were used because those were the names
 *      used in the publication.
 *
 *
 */
void SHA1ProcessMessageBlock(SHA1Context *context)
{
 const unsigned K[] =            /* Constants defined in SHA-1   */
 {
 0x5A827999,
 0x6ED9EBA1,
 0x8F1BBCDC,
 0xCA62C1D6
 };
 int         t;                  /* Loop counter                 */
 unsigned    temp;               /* Temporary word value         */
 unsigned    W[80];              /* Word sequence                */
 unsigned    A, B, C, D, E;      /* Word buffers                 */

 /*
 *  Initialize the first 16 words in the array W
 */
 for(t = 0; t < 16; t++)
 {
 W[t] = ((unsigned) context->Message_Block[t * 4]) << 24;
 W[t] |= ((unsigned) context->Message_Block[t * 4 + 1]) << 16;
 W[t] |= ((unsigned) context->Message_Block[t * 4 + 2]) << 8;
 W[t] |= ((unsigned) context->Message_Block[t * 4 + 3]);
 }

 for(t = 16; t < 80; t++)
 {
 W[t] = SHA1CircularShift(1,W[t-3] ^ W[t-8] ^ W[t-14] ^ W[t-16]);
 }

 A = context->Message_Digest[0];
 B = context->Message_Digest[1];
 C = context->Message_Digest[2];
 D = context->Message_Digest[3];
 E = context->Message_Digest[4];

 for(t = 0; t < 20; t++)
 {
 temp =  SHA1CircularShift(5,A) +
 ((B & C) | ((~B) & D)) + E + W[t] + K[0];
 temp &= 0xFFFFFFFF;
 E = D;
 D = C;
 C = SHA1CircularShift(30,B);
 B = A;
 A = temp;
 }

 for(t = 20; t < 40; t++)
 {
 temp = SHA1CircularShift(5,A) + (B ^ C ^ D) + E + W[t] + K[1];
 temp &= 0xFFFFFFFF;
 E = D;
 D = C;
 C = SHA1CircularShift(30,B);
 B = A;
 A = temp;
 }

 for(t = 40; t < 60; t++)
 {
 temp = SHA1CircularShift(5,A) +
 ((B & C) | (B & D) | (C & D)) + E + W[t] + K[2];
 temp &= 0xFFFFFFFF;
 E = D;
 D = C;
 C = SHA1CircularShift(30,B);
 B = A;
 A = temp;
 }

 for(t = 60; t < 80; t++)
 {
 temp = SHA1CircularShift(5,A) + (B ^ C ^ D) + E + W[t] + K[3];
 temp &= 0xFFFFFFFF;
 E = D;
 D = C;
 C = SHA1CircularShift(30,B);
 B = A;
 A = temp;
 }

 context->Message_Digest[0] =
 (context->Message_Digest[0] + A) & 0xFFFFFFFF;
 context->Message_Digest[1] =
 (context->Message_Digest[1] + B) & 0xFFFFFFFF;
 context->Message_Digest[2] =
 (context->Message_Digest[2] + C) & 0xFFFFFFFF;
 context->Message_Digest[3] =
 (context->Message_Digest[3] + D) & 0xFFFFFFFF;
 context->Message_Digest[4] =
 (context->Message_Digest[4] + E) & 0xFFFFFFFF;

 context->Message_Block_Index = 0;
}

/*
 *  SHA1PadMessage
 *
 *  Description:
 *      According to the standard, the message must be padded to an even
 *      512 bits.  The first padding bit must be a '1'.  The last 64
 *      bits represent the length of the original message.  All bits in
 *      between should be 0.  This function will pad the message
 *      according to those rules by filling the Message_Block array
 *      accordingly.  It will also call SHA1ProcessMessageBlock()
 *      appropriately.  When it returns, it can be assumed that the
 *      message digest has been computed.
 *
 *  Parameters:
 *      context: [in/out]
 *          The context to pad
 *
 *  Returns:
 *      Nothing.
 *
 *  Comments:
 *
 */
void SHA1PadMessage(SHA1Context *context)
{
 /*
 *  Check to see if the current message block is too small to hold
 *  the initial padding bits and length.  If so, we will pad the
 *  block, process it, and then continue padding into a second
 *  block.
 */
 if (context->Message_Block_Index > 55)
 {
 context->Message_Block[context->Message_Block_Index++] = 0x80;
 while(context->Message_Block_Index < 64)
 {
 context->Message_Block[context->Message_Block_Index++] = 0;
 }

 SHA1ProcessMessageBlock(context);

 while(context->Message_Block_Index < 56)
 {
 context->Message_Block[context->Message_Block_Index++] = 0;
 }
 }
 else
 {
 context->Message_Block[context->Message_Block_Index++] = 0x80;
 while(context->Message_Block_Index < 56)
 {
 context->Message_Block[context->Message_Block_Index++] = 0;
 }
 }

 /*
 *  Store the message length as the last 8 octets
 */
 context->Message_Block[56] = (context->Length_High >> 24 ) & 0xFF;
 context->Message_Block[57] = (context->Length_High >> 16 ) & 0xFF;
 context->Message_Block[58] = (context->Length_High >> 8 ) & 0xFF;
 context->Message_Block[59] = (context->Length_High) & 0xFF;
 context->Message_Block[60] = (context->Length_Low >> 24 ) & 0xFF;
 context->Message_Block[61] = (context->Length_Low >> 16 ) & 0xFF;
 context->Message_Block[62] = (context->Length_Low >> 8 ) & 0xFF;
 context->Message_Block[63] = (context->Length_Low) & 0xFF;

 SHA1ProcessMessageBlock(context);
}

int sha1_hash(const char *source, char *lrvar)
// ----------------------------------------------------------------------------
// HASH:es a string with SHA1 and stores resulting hash in lrvar variable
//
// Parameters:
//        source    Pointer to source string to HASH
//        lrvar     LR variable where base64 encoded string is stored
//
// Result
//        -1        Error
//        >0        Success. Actual value is length of HASH string
//
// Example:
//        sha1_hash( "abc", "sha1" )  // sha1=A9993E364706816ABA3E25717850C26C9CD0D89D
// ----------------------------------------------------------------------------
{
 SHA1Context sha;
 char buf[128];

 SHA1Reset(&sha);
 SHA1Input(&sha, source, strlen(source));

 if (!SHA1Result(&sha))
 {
 lr_error_message("SHA1 ERROR: Could not compute message digest");

 return -1;
 }
 else
 {
 // Clear Buffer
 memset(buf,0,sizeof(buf));

 // Store HASH in buffer
 sprintf(buf, "%08X%08X%08X%08X%08X", sha.Message_Digest[0],sha.Message_Digest[1],
 sha.Message_Digest[2],sha.Message_Digest[3],sha.Message_Digest[4]);

 // Save to LR variable
 lr_save_string(buf, lrvar);

 // Return length of string (>0 = success)
 return strlen(buf);
 }
}

LoadRunner has lr_save_int() and lr_save_string() but the float saving function is missing so I just quickly whipped up the following code. It’s by no means perfect when it comes to checking for errors, but it will work >90% of the times (as long as the scripter knows what he/she is doing).. Enjoy.

void lr_save_float(const float value, const char *param, const int decimals)
// ----------------------------------------------------------------------------
// Saves a float into a lr variable, much like lr_save_int() saves an integer
//
// Parameters:
//   value       Float value to store
//   param       Loadrunner variable name
//   decimals    Number of decimals in the result string
//
// Returns:
//   N/A
//
// Example:
//   lr_save_float(123.456, "myVar", 2);  // myVar = 123.46 (includes rounding)
//
// ----------------------------------------------------------------------------
{
  char buf[64];                              // if more>63 digits -> your problem :)
  char formatbuf[16];                        // 16 chars should be adequate

  sprintf( formatbuf, "%%.%df", decimals);   // Build the "%?.f" format string
  sprintf( buf, formatbuf, value);           // sprintf the value
  lr_save_string( buf, param);               // store in variable
}