CSC/ECE 517 Summer 2008/wiki1 5 bk

Hooking Concept

The hooking mechanism in Ruby allows functional events inside a running program to be identified while providing an action that will occur upon detection of the specified event. In this way, hooks serve as a detector of actions within the code, when event x is encountered, y will be performed. Examples where such a technique would prove useful include:

• Recording when or how many times a method is called.
• Recording when an object is created.
• Debugging problematic code.

Example of Hooking System Calls (citation)

The following is an example of a hook being inserted to perform a certain action when the program makes a system call. In order for this to occur, an alias must be created so that the original functionality can still be accessed. In this case, original_system is aliased to the unaltered system. Once this is done, we can freely modify the definition of system to perform just about any operation. This is similar to the way in which a nefarious hook would work by still performing the intended operation, but also appending something extra...

alias_method :original_system, :system

The following code will then proceed to print the command executed ("ls -al" in this case), the timestamp, and then finally the output of the command to standard output.

module Kernel
  alias_method :original_system, :system
  def system(*args)
    puts "Your program executed the \"#{args.join(', ')}\" command." 
    puts "It was executed at: " + `date`
    puts "The command output the following: "
    original_system(*args)
  end
end
system("ls -al")

Your program executed the "ls -al" command. It was executed at: Mon Jun 2 21:19:27 EDT 2008 The command output the following: total 20 drwxr-xr-x 2 brking brking 4096 2008-06-02 21:19 . drwxr-xr-x 18 brking brking 4096 2008-06-02 21:19 .. -rw-r--r-- 1 brking brking 134 2008-06-01 22:01 fib.rb -rw-r--r-- 1 brking brking 235 2008-06-02 20:29 hooking.rb -rw-r--r-- 1 brking brking 287 2008-06-02 21:19 moreHooking.rb

Similarly, a method could be hooked to perform additional tasks upon calling the method. The method would still carry out its original functionality, but the new instructions would precede or follow. It is important to point out that while Ruby supports hooking as part of the language, Java does not. However, similar functionality to hooking is provided through Aspect Oriented tools in both languages. A discussion of the specific implementations as well as their advantages and disadvantages with respect to native hooking follows.

Aspect-Oriented Programming Concept

Aspect-oriented programming deals with abstracting operations in code which are independent of the main purpose or function of the code. As an illustration, a program may have two completely unrelated classes, an automobile class and a plant class. Setting aside for a moment trying to conceive of an application where the two would reside together, there could potentially be similar data desired from objects of both classes. For example, it might be worthwhile knowing the time in which each object is instantiated, logging events on both objects, or even telling when they pass out of scope, These three commonalities are associated with each object of the class, but have nothing to do specifically with the functionality of the object.

In the aspect-oriented vernacular, code written to obtain this common data is said to be cross-cutting in that it applies to multiple facets of the code, but does not specifically deal with the business functionality of the code. This cross-cutting code is also known as advice. The specific places in the code where it is determined that advice is needed is referred to as a pointcut or jointpoint. From there, the aspect embodies the combination of the jointpoint and advice for use by the program. In the previous example, there would be aspects for timestamps, event logging, and scope tracking [1]. This ability to work on existing code without altering had the added advantage of making it more adaptable to future changes and enhancement requests later in its life cycle. Aspect-oriented programming complements object-oriented programming in that OOP governs top-down relationships while AOP governs left-right relationships within an application [2].

Given the nature of the aspect-oriented approach, it is easy draw parallels with hooking techniques. Ruby hooks can accomplish the same objective as an aspect-oriented tool. The primary aspect-oriented tools for Ruby and Java are AspectR and AspectJ respectively.

AspectR Versus ApectJ

AspectR and AspectJ both facilitate the use of aspect-oriented programming in their respective languages. How they go about doing it does differ. With AspectJ, the AOP code is preprocessed prior to being compiled into bytecode. Essentially there are two compilations. With AspectR, the AOP wrapping is performed at runtime.