Category: Computer Programming

Ruby – XML, XSLT and XPath Tutorial ”; Previous Next What is XML? The Extensible Markup Language (XML) is a markup language much like HTML or SGML. This is recommended by the World Wide Web Consortium and available as an open standard. XML is a portable, open source language that allows programmers to develop applications that can be read by other applications, regardless of operating system and/or developmental language. XML is extremely useful for keeping track of small to medium amounts of data without requiring a SQL-based backbone. XML Parser Architectures and APIs There are two different flavors available for XML parsers − SAX-like (Stream interfaces) − Here you register callbacks for events of interest and then let the parser proceed through the document. This is useful when your documents are large or you have memory limitations, it parses the file as it reads it from disk, and the entire file is never stored in memory. DOM-like (Object tree interfaces) − This is World Wide Web Consortium recommendation wherein the entire file is read into memory and stored in a hierarchical (tree-based) form to represent all the features of an XML document. SAX obviously can”t process information as fast as DOM can when working with large files. On the other hand, using DOM exclusively can really kill your resources, especially if used on a lot of small files. SAX is read-only, while DOM allows changes to the XML file. Since these two different APIs literally complement each other there is no reason why you can”t use them both for large projects. Parsing and Creating XML using Ruby The most common way to manipulate XML is with the REXML library by Sean Russell. Since 2002, REXML has been part of the standard Ruby distribution. REXML is a pure-Ruby XML processor conforming to the XML 1.0 standard. It is a non-validating processor, passing all of the OASIS non-validating conformance tests. REXML parser has the following advantages over other available parsers − It is written 100 percent in Ruby. It can be used for both SAX and DOM parsing. It is lightweight, less than 2000 lines of code. Methods and classes are really easy-to-understand. SAX2-based API and Full XPath support. Shipped with Ruby installation and no separate installation is required. For all our XML code examples, let”s use a simple XML file as an input − <collection shelf = “New Arrivals”> <movie title = “Enemy Behind”> <type>War, Thriller</type> <format>DVD</format> <year>2003</year> <rating>PG</rating> <stars>10</stars> <description>Talk about a US-Japan war</description> </movie> <movie title = “Transformers”> <type>Anime, Science Fiction</type> <format>DVD</format> <year>1989</year> <rating>R</rating> <stars>8</stars> <description>A schientific fiction</description> </movie> <movie title = “Trigun”> <type>Anime, Action</type> <format>DVD</format> <episodes>4</episodes> <rating>PG</rating> <stars>10</stars> <description>Vash the Stampede!</description> </movie> <movie title = “Ishtar”> <type>Comedy</type> <format>VHS</format> <rating>PG</rating> <stars>2</stars> <description>Viewable boredom</description> </movie> </collection> DOM-like Parsing Let”s first parse our XML data in tree fashion. We begin by requiring the rexml/document library; often we do an include REXML to import into the top-level namespace for convenience. #!/usr/bin/ruby -w require ”rexml/document” include REXML xmlfile = File.new(“movies.xml”) xmldoc = Document.new(xmlfile) # Now get the root element root = xmldoc.root puts “Root element : ” + root.attributes[“shelf”] # This will output all the movie titles. xmldoc.elements.each(“collection/movie”){ |e| puts “Movie Title : ” + e.attributes[“title”] } # This will output all the movie types. xmldoc.elements.each(“collection/movie/type”) { |e| puts “Movie Type : ” + e.text } # This will output all the movie description. xmldoc.elements.each(“collection/movie/description”) { |e| puts “Movie Description : ” + e.text } This will produce the following result − Root element : New Arrivals Movie Title : Enemy Behind Movie Title : Transformers Movie Title : Trigun Movie Title : Ishtar Movie Type : War, Thriller Movie Type : Anime, Science Fiction Movie Type : Anime, Action Movie Type : Comedy Movie Description : Talk about a US-Japan war Movie Description : A schientific fiction Movie Description : Vash the Stampede! Movie Description : Viewable boredom SAX-like Parsing To process the same data, movies.xml, file in a stream-oriented way we will define a listener class whose methods will be the target of callbacks from the parser. NOTE − It is not suggested to use SAX-like parsing for a small file, this is just for a demo example. #!/usr/bin/ruby -w require ”rexml/document” require ”rexml/streamlistener” include REXML class MyListener include REXML::StreamListener def tag_start(*args) puts “tag_start: #{args.map {|x| x.inspect}.join(”, ”)}” end def text(data) return if data =~ /^w*$/ # whitespace only abbrev = data[0..40] + (data.length > 40 ? “…” : “”) puts ” text : #{abbrev.inspect}” end end list = MyListener.new xmlfile = File.new(“movies.xml”) Document.parse_stream(xmlfile, list) This will produce the following result − tag_start: “collection”, {“shelf”=>”New Arrivals”} tag_start: “movie”, {“title”=>”Enemy Behind”} tag_start: “type”, {} text : “War, Thriller” tag_start: “format”, {} tag_start: “year”, {} tag_start: “rating”, {} tag_start: “stars”, {} tag_start: “description”, {} text : “Talk about a US-Japan war” tag_start: “movie”, {“title”=>”Transformers”} tag_start: “type”, {} text : “Anime, Science Fiction” tag_start: “format”, {} tag_start: “year”, {} tag_start: “rating”, {} tag_start: “stars”, {} tag_start: “description”, {} text : “A schientific fiction” tag_start: “movie”, {“title”=>”Trigun”} tag_start: “type”, {} text : “Anime, Action” tag_start: “format”, {} tag_start: “episodes”, {} tag_start: “rating”, {} tag_start: “stars”, {} tag_start: “description”, {} text : “Vash the Stampede!” tag_start: “movie”, {“title”=>”Ishtar”} tag_start: “type”, {} tag_start: “format”, {} tag_start: “rating”, {} tag_start: “stars”, {} tag_start: “description”, {} text : “Viewable boredom” XPath and Ruby An alternative way to view XML is XPath. This is a kind of pseudo-language that describes how to locate specific elements and attributes in an XML document, treating that document as a logical ordered tree. REXML has XPath support via the XPath class. It assumes tree-based parsing (document object model) as we have seen above. #!/usr/bin/ruby -w require ”rexml/document” include REXML xmlfile = File.new(“movies.xml”) xmldoc = Document.new(xmlfile) # Info for the first movie found movie = XPath.first(xmldoc, “//movie”) p movie # Print out all the movie types XPath.each(xmldoc, “//type”) { |e| puts e.text } # Get an array of all of the movie formats. names = XPath.match(xmldoc, “//format”).map {|x| x.text } p

Web Services with Ruby – SOAP4R ”; Previous Next What is SOAP? The Simple Object Access Protocol (SOAP), is a cross-platform and language-independent RPC protocol based on XML and, usually (but not necessarily) HTTP. It uses XML to encode the information that makes the remote procedure call, and HTTP to transport that information across a network from clients to servers and vice versa. SOAP has several advantages over other technologies like COM, CORBA etc: for example, its relatively cheap deployment and debugging costs, its extensibility and ease-of-use, and the existence of several implementations for different languages and platforms. Please refer to our simple tutorial SOAP to understand it in detail. This chapter makes you familiar with the SOAP implementation for Ruby (SOAP4R). This is a basic tutorial, so if you need a deep detail, you would need to refer other resources. Installing SOAP4R SOAP4R is the SOAP implementation for Ruby developed by Hiroshi Nakamura and can be downloaded from − NOTE − There may be a great chance that you already have installed this component. Download SOAP If you are aware of gem utility then you can use the following command to install SOAP4R and related packages. $ gem install soap4r –include-dependencies If you are working on Windows, then you need to download a zipped file from the above location and need to install it using the standard installation method by running ruby install.rb. Writing SOAP4R Servers SOAP4R supports two different types of servers − CGI/FastCGI based (SOAP::RPC::CGIStub) Standalone (SOAP::RPC:StandaloneServer) This chapter gives detail on writing a stand alone server. The following steps are involved in writing a SOAP server. Step 1 – Inherit SOAP::RPC::StandaloneServer Class To implement your own stand alone server you need to write a new class, which will be child of SOAP::StandaloneServer as follows − class MyServer < SOAP::RPC::StandaloneServer …………… end NOTE − If you want to write a FastCGI based server then you need to take SOAP::RPC::CGIStub as parent class, rest of the procedure will remain the same. Step 2 – Define Handler Methods Second step is to write your Web Services methods, which you would like to expose to the outside world. They can be written as simple Ruby methods. For example, let”s write two methods to add two numbers and divide two numbers − class MyServer < SOAP::RPC::StandaloneServer …………… # Handler methods def add(a, b) return a &plus; b end def div(a, b) return a / b end end Step 3 – Expose Handler Methods Next step is to add our defined methods to our server. The initialize method is used to expose service methods with one of the two following methods − class MyServer < SOAP::RPC::StandaloneServer def initialize(*args) add_method(receiver, methodName, *paramArg) end end Here is the description of the parameters − Sr.No. Parameter & Description 1 receiver The object that contains the methodName method. You define the service methods in the same class as the methodDef method, this parameter is self. 2 methodName The name of the method that is called due to an RPC request. 3 paramArg Specifies, when given, the parameter names and parameter modes. To understand the usage of inout or out parameters, consider the following service method that takes two parameters (inParam and inoutParam), returns one normal return value (retVal) and two further parameters: inoutParam and outParam − def aMeth(inParam, inoutParam) retVal = inParam &plus; inoutParam outParam = inParam . inoutParam inoutParam = inParam * inoutParam return retVal, inoutParam, outParam end Now, we can expose this method as follows − add_method(self, ”aMeth”, [ %w(in inParam), %w(inout inoutParam), %w(out outParam), %w(retval return) ]) Step 4 – Start the Server The final step is to start your server by instantiating one instance of the derived class and calling start method. myServer = MyServer.new(”ServerName”, ”urn:ruby:ServiceName”, hostname, port) myServer.start Here is the description of required parameters − Sr.No. Parameter & Description 1 ServerName A server name, you can give what you like most. 2 urn:ruby:ServiceName Here urn:ruby is constant but you can give a unique ServiceName name for this server. 3 hostname Specifies the hostname on which this server will listen. 4 port An available port number to be used for the web service. Example Now, using the above steps, let us write one standalone server − require “soap/rpc/standaloneserver” begin class MyServer < SOAP::RPC::StandaloneServer # Expose our services def initialize(*args) add_method(self, ”add”, ”a”, ”b”) add_method(self, ”div”, ”a”, ”b”) end # Handler methods def add(a, b) return a &plus; b end def div(a, b) return a / b end end server = MyServer.new(“MyServer”, ”urn:ruby:calculation”, ”localhost”, 8080) trap(”INT){ server.shutdown } server.start rescue => err puts err.message end When executed, this server application starts a standalone SOAP server on localhost and listens for requests on port 8080. It exposes one service methods, add and div, which takes two parameters and return the result. Now, you can run this server in background as follows − $ ruby MyServer.rb& Writing SOAP4R Clients The SOAP::RPC::Driver class provides support for writing SOAP client applications. This chapter describes this class and demonstrate its usage on the basis of an application. Following is the bare minimum information you would need to call a SOAP service − The URL of the SOAP service (SOAP Endpoint URL). The namespace of the service methods (Method Namespace URI). The names of the service methods and their parameters. Now, we will write a SOAP client which would call service methods defined in above example, named add and div. Here are the main steps to create a SOAP client. Step 1 – Create a SOAP Driver Instance We create an instance of SOAP::RPC::Driver by calling its new method as follows − SOAP::RPC::Driver.new(endPoint, nameSpace, soapAction) Here is the description of required parameters − Sr.No. Parameter & Description 1 endPoint URL of the SOAP server to connect with. 2 nameSpace The namespace to use for all RPCs done with this SOAP::RPC::Driver object. 3 soapAction A value for the SOAPAction field of the HTTP header. If nil this defaults to the empty string “”. Step 2

Ruby – Multithreading ”; Previous Next Traditional programs have a single thread of execution the statements or instructions that comprise the program are executed sequentially until the program terminates. A multithreaded program has more than one thread of execution. Within each thread, statements are executed sequentially, but the threads themselves may be executed in parallel on a multicore CPU, for example. Often on a single CPU machine, multiple threads are not actually executed in parallel, but parallelism is simulated by interleaving the execution of the threads. Ruby makes it easy to write multi-threaded programs with the Thread class. Ruby threads are a lightweight and efficient way to achieve concurrency in your code. Creating Ruby Threads To start a new thread, just associate a block with a call to Thread.new. A new thread will be created to execute the code in the block, and the original thread will return from Thread.new immediately and resume execution with the next statement − # Thread #1 is running here Thread.new { # Thread #2 runs this code } # Thread #1 runs this code Example Here is an example, which shows how we can use multi-threaded Ruby program. #!/usr/bin/ruby def func1 i = 0 while i<=2 puts “func1 at: #{Time.now}” sleep(2) i = i&plus;1 end end def func2 j = 0 while j<=2 puts “func2 at: #{Time.now}” sleep(1) j = j&plus;1 end end puts “Started At #{Time.now}” t1 = Thread.new{func1()} t2 = Thread.new{func2()} t1.join t2.join puts “End at #{Time.now}” This will produce following result − Started At Wed May 14 08:21:54 -0700 2008 func1 at: Wed May 14 08:21:54 -0700 2008 func2 at: Wed May 14 08:21:54 -0700 2008 func2 at: Wed May 14 08:21:55 -0700 2008 func1 at: Wed May 14 08:21:56 -0700 2008 func2 at: Wed May 14 08:21:56 -0700 2008 func1 at: Wed May 14 08:21:58 -0700 2008 End at Wed May 14 08:22:00 -0700 2008 Thread Lifecycle A new threads are created with Thread.new. You can also use the synonyms Thread.start and Thread.fork. There is no need to start a thread after creating it, it begins running automatically when CPU resources become available. The Thread class defines a number of methods to query and manipulate the thread while it is running. A thread runs the code in the block associated with the call to Thread.new and then it stops running. The value of the last expression in that block is the value of the thread, and can be obtained by calling the value method of the Thread object. If the thread has run to completion, then the value returns the thread”s value right away. Otherwise, the value method blocks and does not return until the thread has completed. The class method Thread.current returns the Thread object that represents the current thread. This allows threads to manipulate themselves. The class method Thread.main returns the Thread object that represents the main thread. This is the initial thread of execution that began when the Ruby program was started. You can wait for a particular thread to finish by calling that thread”s Thread.join method. The calling thread will block until the given thread is finished. Threads and Exceptions If an exception is raised in the main thread, and is not handled anywhere, the Ruby interpreter prints a message and exits. In threads, other than the main thread, unhandled exceptions cause the thread to stop running. If a thread t exits because of an unhandled exception, and another thread s calls t.join or t.value, then the exception that occurred in t is raised in the thread s. If Thread.abort_on_exception is false, the default condition, an unhandled exception simply kills the current thread and all the rest continue to run. If you would like any unhandled exception in any thread to cause the interpreter to exit, set the class method Thread.abort_on_exception to true. t = Thread.new { … } t.abort_on_exception = true Thread Variables A thread can normally access any variables that are in scope when the thread is created. Variables local to the block of a thread are local to the thread, and are not shared. Thread class features a special facility that allows thread-local variables to be created and accessed by name. You simply treat the thread object as if it were a Hash, writing to elements using []= and reading them back using []. In this example, each thread records the current value of the variable count in a threadlocal variable with the key mycount. Live Demo #!/usr/bin/ruby count = 0 arr = [] 10.times do |i| arr[i] = Thread.new { sleep(rand(0)/10.0) Thread.current[“mycount”] = count count &plus;= 1 } end arr.each {|t| t.join; print t[“mycount”], “, ” } puts “count = #{count}” This produces the following result − 8, 0, 3, 7, 2, 1, 6, 5, 4, 9, count = 10 The main thread waits for the subthreads to finish and then prints out the value of count captured by each. Thread Priorities The first factor that affects the thread scheduling is the thread priority: high-priority threads are scheduled before low-priority threads. More precisely, a thread will only get CPU time if there are no higher-priority threads waiting to run. You can set and query the priority of a Ruby Thread object with priority = and priority. A newly created thread starts at the same priority as the thread that created it. The main thread starts off at priority 0. There is no way to set the priority of a thread before it starts running. A thread can, however, raise or lower its own priority as the first action it takes. Thread Exclusion If two threads share access to the same data, and at least one of the threads modifies that data, you must take special care to ensure that no thread can ever see the data in an inconsistent state. This is called thread exclusion. Mutex is a class that implements a simple semaphore lock for mutually exclusive access to some shared resource. That is, only one thread

Sending Email using Ruby – SMTP ”; Previous Next Simple Mail Transfer Protocol (SMTP) is a protocol, which handles sending e-mail and routing e-mail between mail servers. Ruby provides Net::SMTP class for Simple Mail Transfer Protocol (SMTP) client-side connection and provides two class methods new and start. The new takes two parameters − The server name defaulting to localhost. The port number defaulting to the well-known port 25. The start method takes these parameters − The server − IP name of the SMTP server, defaulting to localhost. The port − Port number, defaulting to 25. The domain − Domain of the mail sender, defaulting to ENV[“HOSTNAME”]. The account − Username, default is nil. The password − User password, defaulting to nil. The authtype − Authorization type, defaulting to cram_md5. An SMTP object has an instance method called sendmail, which will typically be used to do the work of mailing a message. It takes three parameters − The source − A string or array or anything with an each iterator returning one string at a time. The sender − A string that will appear in the from field of the email. The recipients − A string or an array of strings representing the recipients” addressee(s). Example Here is a simple way to send one email using Ruby script. Try it once − require ”net/smtp” message = <<MESSAGE_END From: Private Person <me&commat;fromdomain.com> To: A Test User <test&commat;todomain.com> Subject: SMTP e-mail test This is a test e-mail message. MESSAGE_END Net::SMTP.start(”localhost”) do |smtp| smtp.send_message message, ”me&commat;fromdomain.com”, ”test&commat;todomain.com” end Here, you have placed a basic e-mail in message, using a document, taking care to format the headers correctly. E-mails require a From, To, and Subject header, separated from the body of the e-mail with a blank line. To send the mail you use Net::SMTP to connect to the SMTP server on the local machine and then use the send_message method along with the message, the from address, and the destination address as parameters (even though the from and to addresses are within the e-mail itself, these aren”t always used to route mail). If you”re not running an SMTP server on your machine, you can use the Net::SMTP to communicate with a remote SMTP server. Unless you”re using a webmail service (such as Hotmail or Yahoo! Mail), your e-mail provider will have provided you with outgoing mail server details that you can supply to Net::SMTP, as follows − Net::SMTP.start(”mail.your-domain.com”) This line of code connects to the SMTP server on port 25 of mail.your-domain.com without using any username or password. If you need to, though, you can specify port number and other details. For example − Net::SMTP.start(”mail.your-domain.com”, 25, ”localhost”, ”username”, ”password” :plain) This example connects to the SMTP server at mail.your-domain.com using a username and password in plain text format. It identifies the client”s hostname as localhost. Sending an HTML e-mail using Ruby When you send a text message using Ruby then all the content will be treated as simple text. Even if you will include HTML tags in a text message, it will be displayed as simple text and HTML tags will not be formatted according to HTML syntax. But Ruby Net::SMTP provides option to send an HTML message as actual HTML message. While sending an email message you can specify a Mime version, content type and character set to send an HTML email. Example Following is the example to send HTML content as an email. Try it once − require ”net/smtp” message = <<MESSAGE_END From: Private Person <me&commat;fromdomain.com> To: A Test User <test&commat;todomain.com> MIME-Version: 1.0 Content-type: text/html Subject: SMTP e-mail test This is an e-mail message to be sent in HTML format <b>This is HTML message.</b> <h1>This is headline.</h1> MESSAGE_END Net::SMTP.start(”localhost”) do |smtp| smtp.send_message message, ”me&commat;fromdomain.com”, ”test&commat;todomain.com” end Sending Attachments as an e-mail To send an email with mixed content requires to set Content-type header to multipart/mixed. Then text and attachment sections can be specified within boundaries. A boundary is started with two hyphens followed by a unique number, which cannot appear in the message part of the email. A final boundary denoting the email”s final section must also end with two hyphens. Attached files should be encoded with the pack(“m”) function to have base64 encoding before transmission. Example Following is the example, which will send a file /tmp/test.txt as an attachment. require ”net/smtp” filename = “/tmp/test.txt” # Read a file and encode it into base64 format filecontent = File.read(filename) encodedcontent = [filecontent].pack(“m”) # base64 marker = “AUNIQUEMARKER” body = <<EOF This is a test email to send an attachement. EOF # Define the main headers. part1 = <<EOF From: Private Person <me&commat;fromdomain.net> To: A Test User <test&commat;todmain.com> Subject: Sending Attachement MIME-Version: 1.0 Content-Type: multipart/mixed; boundary = #{marker} –#{marker} EOF # Define the message action part2 = <<EOF Content-Type: text/plain Content-Transfer-Encoding:8bit #{body} –#{marker} EOF # Define the attachment section part3 = <<EOF Content-Type: multipart/mixed; name = “#{filename}” Content-Transfer-Encoding:base64 Content-Disposition: attachment; filename = “#{filename}” #{encodedcontent} –#{marker}– EOF mailtext = part1 &plus; part2 &plus; part3 # Let”s put our code in safe area begin Net::SMTP.start(”localhost”) do |smtp| smtp.sendmail(mailtext, ”me&commat;fromdomain.net”, [”test&commat;todmain.com”]) end rescue Exception => e print “Exception occured: ” &plus; e end NOTE − You can specify multiple destinations inside the array but they should be separated by comma. Print Page Previous Next Advertisements ”;