Andreas Happe » Software Development

Generating PDFs from Ruby on Rails

andy — Wed, 03 Mar 2010 12:25:45 +0000

The problem

Ruby on Rails provides various helpers for generating dynamic web content but sometimes you need documents that users can easily store and share between them. The ubiquitous file format for this is Adobe PDF nowadays.

The common solution fro this problem is Prawn [github, introduction]. Alas it requires a custom DSL for document description, no existing Rails views or partials can be reused. An alternative is princeXML which transforms HTML/CSS into pdf through an external binary. This would allow reuse of existing templates and knowledge (think CSS designers) but has the downside of its price tag of $3800.

The solution

Enters wicked_pdf: it utilizes wkhtmltopdf to create a PDF document from a Rails HTML template. HTML rendering is done through the well-known webkit-engine. This allows developers to do PDFs in the right way™: define the document’s structure through a simple HTML document and theme them through CSS. You’ll get the automatic benefit of themability: exchange the CSS and you have another format. There are also lots of CSS artists out there that can supply you with different designs.

I’ve used this solution with a test Ruby on Rails 3.0-beta application, the steps involved were:

Install wkhtmltopdf:

This program will convert the HTML into the PDF format. To make it work you’ll need at least version 0.9 which isn’t installed in Ubuntu 9.10 by default. Just download the static compiled version from the wkhtmltopdf website and place it under /usr/local/bin.

Install the wicked_pdf plugin:

Just install it in the usual Rails way:

git submodule add git://github.com/mileszs/wicked_pdf.git vendor/plugins/wicked_pdf

Additionally a sample configuration file is needed. You could use the plugin’s generator script for it but alas this didn’t work for me with Rails 3.0. Let’s just copy it form the plugin’s directory into config/initializers.

$ cp vendor/plugins/wicked_pdf/generators/wicked_pdf/templates/wicked_pdf.rb config/initializers

and alter the wkhtmltopdf path within it:

  WICKED_PDF = {
       :exe_path => '/usr/local/bin/wkhtmltopdf-amd64'
  }

Add pdf instructions to your controller..

For example I’m using the invoice#index action to render a simple PDF document.

  format.pdf do
          @example_text = "some text"
          render :pdf => "file_name",
                 :template => 'offers/show.pdf.erb',
                 :layout => 'pdf',
                 :footer => {
                    :center => "Center",
                    :left => "Left",
                    :right => "Right"
                 }
  end

We are rendering the view with a predefined footer containing some sample “center”, “left” and “right” strings. The render :pdf call has various options which can be seen on the wicked_pdf homepage.

.. and create PDF templates

The other half of the PDF templates is the view code consisting of a special layout and template for pdf generation.

The layout (app/views/layouts/pdf.html.erb) resembles a normal Ruby on Rails layout file:



  
    
    <%= wicked_pdf_stylesheet_link_tag "pdf" %>
  
  
    
      <%= yield %>

The view code should not be too surprising, just place it under app/views/offers/index.pdf.erb :

<%= @example_text %>

Lets also create a simple CSS file (public/stylesheets/pdf.css):

#someid {
  margin-left: 430px;
  display: float;
  height: 150px;
  background-color: green;
  width: 250px;
}

This is the whole rendering code.

Reference the PDF view and download it

We still need a reference to the newly created rendernig link, we can easily create this through:

link_to 'Create PDF document', invoice_path(@invoice, :format => :pdf)

When the link is clicked a pdf document will be generated and downloaded.

Conclusion

wicked_pdf allows easy pdf generation in a very Ruby on Rails’ way. It’s free, it works and is easy to employ..

..but not everything is perfect within the wicked_pdf world, especially error handlnig is lacking sometimes. When you’ve debugging initial problems you can expect the only error feedback to be a HTTP return code of 406. Just start with limited controller (rendering) options and double check that you’ve referenced the right view and layout paths and you should be fine.

No related posts.

SECOQC: We’ve done it

andy — Sun, 12 Oct 2008 19:01:34 +0000

Over the last one and a half years I’ve been involved with the SECOQC project. It’s goal was to provide a prototype of a quantum key distribution network. Such a system would provide unconditional security, thus wouldn’t be isn’t vulnerable to improvements in computing power as traditional cryptography.

The final presentation of the prototype happened this Wednesday. The last days and nights before that were filled with applying the last fixed but finally it was worth the time. But let the newspapers do the talking: orf, heise, der standard, sueddeutsche, Austrian Telekom News. There was quite good news coverage in german-speaking Europe (and some eastern europe countries) but sadly the news didn’t seem to have jumped over the pond (at least some American physicists were at the presentation so it got noticed anyway).

Feels strange to know that something that big and cutting-edge is finally successfully finished.. and that I’m an unemployed student agai

No related posts.

Ruby on Rails vs. Java part2

andy — Sun, 24 Feb 2008 15:07:00 +0000

As mentioned in part 1 my task is implementing a mail and campaigning module. I started out with a pure Ruby on Rails application and moved to a mixed Java/Rails applications as Ruby’s communication libraries where just lacking mandatory features. I choose Java/Hibernate/Spring as the combination should provide me with most needed features through an easily extend- and configurable framework. What are my findings so far?

Lines of Code comparison

Ruby beats Java if you want an easy and fast web development framework, but as soon as you exit the web user interface niche it looses many of its advantages, still the lines-of-code count in java is around 4 to 6 times as large as Rails’s. Good for you if you’re paid by the line of code that you write, bad for you if you want to get things done.

Both frameworks rely on convention over configuration. As I wrote the Java application after the Rail’s one I had to configure Java to fit Rail’s way which resulted in lots of configuration which would be unnecessary if I’d written the application in Java from day one. Much of the simpler code (setter/getter for entity classes) were also auto-generated, so the LOC count should be looked at with a grain of salt.

Readability

The Java code is better readable which surprised me. While the Ruby code is more verbose and beatifuller the Java code tends to be longer, but overall simpler structured. It is a lot easier to debug and as my application will be deployed as a war file in an Java Enterprise container there’s lot of functionality (e.g. logging) which can easily be tapped. I had some very ugly functions dealing with mime parts in Ruby, those are a lot easier to read because of the static typing. Once again: while duck-typing is perfect for writting an application quick, static typing might come in handy if you want your application to be robust and long-lived.

Different approach to business object authority

Another difference (and source of increased Java LOCs) is the different approach to business object responsibility. That term describes who is responsible for declaring objects, their content and constraints. Rail’s ActiveRecord maps the a database table into a business object data type, a row into an object and a attribute into a class member. Each change in the data backend automatically changes your business objects. You can write automatic tests to check if your object model is still sufficient, but those tests are not run automatically when the application starts. Some definitions (i.e. constraints and relationships) are defined on business object level, so you have split definitions between the database and your object model.

With hibernate you write your business objects and add annotations (as you do with Rails) to describe how they are mapped to the database. But the final authority lies at the application and the business objects. If there’s a database change no attribute appears or disappears automatically, but an exception is raised on application startup. You have to write more code, but you have all your data definitions (incl. tables, attributes, relations and constraints) in one single conceptional place. You can even generate your database layout from your object model.

The later approach is clearer for me (and does less automagic than the Rails approach), but there’s also a payoff: you’ll need many more lines of code to define your business objects. Also if you want to add a change you’ll have to change your data definitions in the database as well as in your application. This will never happen in Rails with it’s D-R-Y way (Dont Repeat Yourself). Choose ease and speed of writing code vs. IMHO more safer code as your database format and input is double checked.

The next part will talk about the differences in Rails and Java/Springs exception handling.

No related posts.

Ruby on Rails vs. Java, part 1

andy — Sun, 17 Feb 2008 17:05:38 +0000

One of the components of the system developed here at Blackwhale is an fairly advanced web mail/campaigning and analytics system. The first iteration of that component was fully implemented in Ruby on Rails. Writing the front end was fairly easy and fast, a perfect opportunity for Rails to display its strengths. On the back end and communication part on the other hand I stumbled into various problems:

Compared to PHP, Python or Java there are just too few communication libraries. And even the libraries that exist are lacking fundamental features and almost all of them come without useable documentation. That there is no encryption (SSL or TLS) support in the whole Ruby 1.8 mail libraries is an outright shame. The IMAP library is so clumsy that a web company sells their own (still not perfect library) through their online store and they seem to make a good buck with it.
On the Java side is just a completly different picture: Lots of libraries, even documented ones are available. After having to touch the TMail (rail’s MIME mail handler library) API using javax.mail is a heavenly gift. And it seems that the TMail generated MIME messages were invalid in a couple of cases. Not the best feature of a support library. Also the chance of finding unsolved known bugs and errors seems to be lot smaller in Java.
This brings me to another point: I might change my opinion on Java’s constraints on its users. Java tries hard to prevent errors (i.e. the forced exception catching). I always thought that that took too many stylish possibilities away from the user, but by now I must confess that I think that this is exactly what I want from something that I’m using on the network side. I’m a lazy programmer, I want to be reminded and forced to write secure and stable code. This is the quite different to Ruby and Rails ‘make it easy for the programmer’ attitude.
Background processing is hard. As Ruby on Rails is not multi-thread safe you can’t just spawn a thread if you need to perform some longer running task. Another disadvantage of using a single-process model is that the long running request will occupy one rails worker (i.e. rails cluster process) until it has finished – in our case that costs us around 60MB of memory per long running request, even if it is just waiting for some simple SMTP feedback. If you can find a situation where you can delay the execution of a network related task (and if you don’t you’re not thinking) for two seconds, 6 requests per seconds will DoS a standard rails cluster.
The only solution that’s actually usable is BackgroundRb. But projects that just change their background communication system just don’t sound to production-grade ready for me. Also the admin start/stop scripts for their background server didn’t work too well for me.
For a language that interferes it’s object’s attribute types directly from the database the ActiveRecord layer is weak. Don’t get me wrong, I understand that the Simplicity is needed to make it easily usable but I ran into various situations where I’d love to have a full blown ORM behind me. One feature that is needed quite often by our application is inheritance. ActiveRecord only offers single table inheritance, and even there you have to make sure that each row is valid (ActiveRecord should have all needed information to do that by itself BTW) or you will run into problems later on. One problem is, that it tries to abstract too much functionality away from the database while not provided as advanced interfaces by itself. Data integrity handling? Abstracted away by rails, so all databases can be used the same. The drawback is, that the data constraints and relations are fully handled by rails and not passed on to the database. Any process that might produce invalid data (e.g. a faulty rails component) might corrupt the data. Rails is able to handle that cases by itself (due to ducktyping and very few default checks), but access that data with any other framework and it blows up directly into your face.
Transaction handling. Just try it. Then cry. Also I’m not sure if Transaction handling is even done on database level or in Rails (as done with constraints). If the later is true, it’s acutally not worth anything as soon as more processes try to access the database.

The library and documentation problems where the main reason for me to reimplement the mailing and campaigning backend in Java. The front end is still a Rails application — which is exactly what Rails is for. As I’m no friend of blown-up EJB based solutions I’ve choosen a simple Spring and JPA based solution for that problem.

I’m currently testing the last features and replacing the Ruby code part by part. As soon as I’ve done that another blog post will examine the two implementations, how much time was spent on coding them and how they perform when compared to each other.

No related posts.

How to enable TLS support in Ruby’s/Rails’ Net::SMTP

andy — Wed, 19 Dec 2007 01:12:10 +0000

Ruby on Rails uses Ruby 1.8 which still lacks support for STARTTLS or SSL. This was added in Ruby 1.9, but as this release is designated to be unstable (and only the road to a stable Ruby 2.0) Rails 2.0 doesn’t support running with it.

What to do? It’s a shame that a web framework like Rails doesn’t support secure transmission of mails.

So I rolled my own Ruby on Rails plugin that extends the base Net::SMTP class with STARTTLS features. You can just call Net::SMTP.enable_tls (or do the same with an instance variable) to enable secure communications.

Honestly I didn’t write all the code on my own but searched the net and adapted some around-floating patches to this plugin as this is the easiest way of providing the needed TLS support to rails.

So if you need it, just grab it from here. More Information can be found in the plugin’s README file. Have fun and share your improvements to the plugin.

No related posts.

How to upgrade to Ruby on Rails 2.0

andy — Mon, 10 Dec 2007 01:36:18 +0000

I wanted to upgrade on project of mine to Ruby on Rails 2.0 to automatically get some security and performance upgrades. So how to do it? My first try was:

checkout a new copy of my project from the SCM
upgrade the used rails version to EdgeRails
(through executing “rake rails:freeze:edge” twice)
adopted the RAILS_VERSION variable in config/environment.rb
Got a “500 Internal Error” without any usable logging information on starting the Rails server (“script/server“)

So what? I upgraded everything as planned and got an error without any real debugging help. What to do now?

After some googling around I found Mislav Marohnic’s excellent r2check.rb script. Just run it in your Rails directory and it will report a lot of errors and deprecated features that might hit you. One of those reported errors was the new notation for singular resources, after it converted my resources.rb the application finally started (albeit I had to fix some errors in the restful_authentication plugin, but nothing to heavy). So now I’m running Rails 2.0.1 and some pages really fell a lot faster.

Thank you very much for that script!

No related posts.

Ruby on Rails redux

andy — Sun, 11 Nov 2007 23:01:47 +0000

Approximately one week ago I claimed that I was happy replacing Ruby on Rails with a conglomerate of Java frameworks. I’ve got wiser. Even with maven2 it’s too hard to get even a simple mavenized spring2, acegi, spring-jpa-hibernate configureation to work.

So I’m back to Rails. By now I feel more comfortable in the framework, but there are still some open issues but most things just work (TM).

You’re an atheist?

Only on Christmas or Easter,
the rest of the time it doesn’t really matter

House, M.D.

No related posts.

Back in Vienna and small stuff

andy — Tue, 06 Nov 2007 02:07:51 +0000

The last four days back home in Carinthia passed too fast.. and as soon as I was back in Vienna work covered me again. I’ve finally finished my climbing lessons, didn’t even miss one of them. Now I hope that I can find the motivation to visit those halls of pain again. I’m more than a little bit proud of my discipline, I even attended each Pencak Silat class until now – alas my performance in those ain’t the best.

I spent most of today’s afternoon coding a quite simple web application using JavaServer Pages with a Spring2, Hibernate and Java Persistence Architecture back-end. Security is handled through acegi, packaging through maven. Although this is more time-consuming compared to the last Ruby on Rails application I coded but there’s less Voodoo involved. Overall the resulting system feels more secure and stable.

No related posts.

Using Apache ActiveMQ

andy — Tue, 18 Sep 2007 12:53:22 +0000

I use Apache ActiveMQ for internal component communicatino in a project of mine. As only local (no distributed or network) communication is needed I configured it to use the VM transport, the fasted and most efficient way according to the online documentation. To prevent overhead objects instead of serialized XML is send through the queue – profiling has shown that using JDOM’s XmlOutputter to generate XML is a major cpu hog. Another advantage of using the VM transport is that no dedicated broker is needed, the internal one is started automatically. So everything is peachy?

Unfortunately not.

The first profile run (using Profiler4J) showed unusual high cpu load while the system was running idle. Further analysis showed that ActiveMQ’s message receive function does do polling to get messages from the queue. This only affects the framework when running idle and shouldn’t use as much cpu when there’s actual work to do but still this is highly disturbing. After investigating the ActiveMQ documentation again (on a side node: there seems to be something that automatically destroys anything resembling documentation as soon as a project joins Apache) I found out that there’s another way of receiving messages. As it was an asynchronous listener based approach it should be easier on the processor. As a nice side effect the receiver side of my application’s action got simpler too.

Better results? No.

More than half of the systems CPU usage in the “now-not-idle-mode-anymore” still is generated by polled message queues. My solution to that problem (due to lack of documentation) was ripping out the ActiveMQ part altogether and replacing it with a simple java.util.concurrent.BlockingQueue. It is thread-safe, simple to use and does a sort of sender side blocking (through a predefined queue size). In addition the data structure is a generic one, so some type-casts are avoided. CPU usage went down, a lot!

So what am I missing in the ActiveMQ picture? As it claims enterprise-grade this should not happen so I’m expecting an error on my side.

No related posts.

object-relational mappers in Java

andy — Sat, 25 Aug 2007 22:21:51 +0000

After some time of absence to the Java, XML buzz world I had to reenter it lately for my master thesis. My current assignment is writing a data attraction and persistence layer. After finding out that there’s a multitude of possible frameworks and systems which I might use for my problem I dived right in, in contrary to BPEL engines most of them also worked.

The first step towards an advanced persistence solution was the usage of a ORM mapper. As the name implies those map between Java objects and relational data structures (i.e. databases). The programmer doesn’t see the underlying database world and just interacts with plain old Java objects. I started by using iBatis which occupies the one extreme of ORMs: the developer has to supply a SQL statement for each mapping. This also implies that the database schema is already defined before the ORMs is used. As I started from scratch I didn’t have a relational model, in fact I wanted to use an object-relational mapper to prevent myself from micro-designing the database layout.

The next contestant was Hibernate. This is one of the if not the most powerful object mapper for Java. In contrast to iBatis the latest version depends solely on Java annotations and a simple config file (which defines the overall database connection and declares which classes are to be mapped). I augmented my Java files and was ready to roll. After a bit of tweaking lazy loading also worked which isn’t to shabby for the invested time. Another advantage of Hibernate is HQL – the Hibernate Query Language: it provides the developer with an easy way of extracting Objects from databases through SQL-like queries.

But finally I settled with the Java Persistence API which is roughly the same as Hibernate but standardized through a JSR. There were minor differences with the annotations, but overall it was even simpler to use (the configuration file that stated which classes were to be persisted fell away). Under the hood I used Hibernate, but just through JPA, so performance and stability where the same.

The only drawback so far is the memory usage. JPA takes just all of it (and the JVM’s behaviour of starting memory reclaim as late as possible doesn’t help either). To ease this up I had to blurry the line between persistence and business layer a bit, this was felt as a step backwards as the goal was to minimize the persistence layer as much as possible.

As one of my thesis’ mentors prefers XML databases I will be able to contrast this to a XML based solution soon.

No related posts.

Andreas Happe » Software Development

Generating PDFs from Ruby on Rails

The problem

The solution

Install wkhtmltopdf:

Install the wicked_pdf plugin:

﻿﻿Add pdf instructions to your controller..

.. and create PDF templates

Reference the PDF view and download it

Conclusion

SECOQC: We’ve done it

Ruby on Rails vs. Java part2

Ruby on Rails vs. Java, part 1

How to enable TLS support in Ruby’s/Rails’ Net::SMTP

How to upgrade to Ruby on Rails 2.0

Ruby on Rails redux

Back in Vienna and small stuff

Using Apache ActiveMQ

object-relational mappers in Java

Add pdf instructions to your controller..