Playing with Merb again on an old box with a positively geriatric install of Ruby, I discovered after some pain that github needs Ruby gems to be at least version 1.2. I subsequently discovered that Ruby also needs to be at 1.8.6 or higher (/cry) – there’s no clean upgrade path for Ruby yet for Windows which means a fresh install.

Add github as a source if you don’t already have it (you can check quickly with “gem sources”)

gem sources –add http://gems.github.com

You will probably have issues with previously installed versions of addressable in which case you’ll need to get the latest version:

gem install addressable

Then all you (probably) have to do is install Merb – there may be issues though which I didn’t experience.

gem install –remote merb

So as I ramp up to do some automation in my business I am looking at Rails as the baseline. So the work going on with Rails 3 caught my eye and I took a spin through an overview given by Yehuda Katz back in May.

· Why it caught my eye Supposedly Merb allows plug in play w/ Rails so you aren’t trapped w/ pieces you don’t like. · Would I recommend you watch it?: If you are hard core into Rails yes as the conversation is very detailed. If you want a layman overview of what Rails 3 is about this is probably not the best angle. · Most Notable Point: Ability to plug and play w/ Rails 3 is the goal and looks viable. Both on ORM and other pieces. · When should you fast forward? No notable slow segments … very detailed. · What some might of missed: Rails Boost looks interesting (a template approach layered on top of rails 2.3)

Seems cool. Not sure if I will work from the alpha rails3 due out shortly or just poke up 2.3. Need to ponder more.

As always, for those amused here are my raw notes:

*** START OF RAW SCRIBBLE TAKEN WHILE RUNNING ***

• Actual presentation

• What to Expect in Rails 3.0 (Rails and Merb)

• Yehuda Katz – 5/22/09

• 0:33.296

…..○ Intro commentary

…..○ Worked on merb full time prior to merge

…..○ Defining audience

……….§ Merb targets the developer that wants to develop apps and extend RoR framework potentially

• 3:53.22 – ORM Agnostic

…..○ Merb

……….§ Form_for … allow activerecord or other types

……….§ Two valid types (valid, errors, new_record)

……….§ Net to two interfaces

…..○ ActionORM (name can change)

……….§ Upgrade on MERB

……….§ Have drivers to make other things pretend to be active records

……….§ I.e. Sequel driver

…..○ Two options – compliance or proxy

……….§ Object.to_model

…..○ 8:21.632 – Code changes required to do above in RoR

……….§ Error_messages_for changes

…..○ Community Extensions

……….§ Adaptor for sql for example

• 10:41.838 – Rack

…..○ MERB 0.05 – No rack, mongrel supported by support

…..○ Support pure rack (Mongrel, Thin, Ebb, CGI, FCGI, Webrick, IRB, Runner)

…..○ Merb 1 – Add some middleware

……….§ PathPrefix, ConditonalGet, Static

• 14:24.377 – Router#call

…..○ Get some rails to behave like rack in certain parts

…..○ Controller.action(:index) … rack object returns …

…..○ Middleware

……….§ Param Parsing (JSON, XML, etc – merge)

……….§ Rescuing – in RoR 2.3 in controller … in 3.0 just another middleware

……….§ Config.middleware.uss Foo to use

…..○ Integration Tests

……….§ Can test app w/ rack aspects with special handling

• 17:16.904 – End Game

…..○ Treat all aspects of Rails, Merb, Sinatra etc as one thing

…..○ Most will use RoR as it works today … but if you want to mount Merb or Sinatra apps … easily to your RoR app

• 18:24.169 – Refactoring Rails internals

…..○ Callbacks

……….§ Around Filters – Unify them – ActionPack, TestCase, Dispatcher, ActiveRecord

……….§ Speed

……………□ Like hello world request returning JSON (10-20% of time)

……………□ Every before_filter fires a ton of stuff (20:38.694)

……………□ Create _run_action_filters … rails compile to one tight method

…..○ ActionDispatch (22:26.253)

……….§ Not controller related … so move to action_dispatch (new)

……….§ Make controllers as fast as Rails Metal

…..○ AbstractController

……….§ Rails mailer, rails controller – same but forks

……….§ Rebuild controller on module approach that is more robust

……………□ Ability to super

……….§ Add new sugar to modules … include will setup super chain correctly

……….§ Layout module depends on renderer

…..○ Example of Rendering (25:51.864)

……….§ Render “foo” – render action foo

……….§ Render :template => “/foo” .. Removes slash (no lookup in abs dir)

……….§ Get Template object … AC::Renderer

……….§ Render Template object … Abstract::Renderer .. gets Template object

……….§ Set HTTP response .. Http base controller

……….§ Set response_body … main AbstractController

……….§ … so top down … normalize as you move up (top down in my list)

• ActionView (28:31.943)

…..○ ViewPathSet#find (single way in) … get Template object

……….§ Ask each of its paths (resolvers) do you have something that matches

……….§ Abstract file system physical from request for a template

…..○ Returns template

…..○ Template#render(self) – controller

…..○ ActionView.long_meth

• Public API (31:30.369)

…..○ Rails has … public doc is the API … one API

…..○ Merb 1 …

……….§ Public

……….§ Private

……….§ Plugin

• Rails 3 (32:43.202)

…..○ TBD

• Debugging

…..○ Rack::Bug (33:11.266)

…..○ Port of Django debug toolbar

…..○ Works in rails 2.3

…..○ Pluggable

…..○ Solution – Orchestra (34:23.441)

……….§ Event system in rails … 100 lines of code

……….§ Hook to ‘render’ event … not system

……….§ Publish a render event … works across stacks

……….§ Longer term goal … one place to override renderer and sequel

……….§ Make alerts custom … don’t block main thread w/ 10 callbacks

• Exception Middleware (36:38.514)

…..○ Rack thing

• Javascript

…..○ Rails 2.3 Bad

…..○ Merb .. Bring your own javascript

…..○ jQuery .. jRails (hard link to rails API – breaks)

…..○ Rails 3

……….§ Instead get javascript out of inline .. Semantic markup

……….§ jQuery example (38:44.851) of what you need

……….§ Separate behavior from markup

……….§ Generate Markup

……………□ Rails.prototype.js (HTML 5 question)

……………□ Rails.dojo.js

……………□ Rails.mootools.js

……………□ Etc

• Competition (40:27.494)

…..○ Remove Merb reduces competition

…..○ Why merger is good

…..○ ActiveRecord and DataMapper .. Allow choice

…..○ ActionController and MetalController … allow choice (for speed)

…..○ Known interfaces (drop our rails parts you don’t want)

…..○ Allow you to drop out pieces of rails that doesn’t work

…..○ Template Engines (42:59.934)

……….§ Good in 2.1 and up (so use rails)

……….§ Merb and ORMs – Work

…..○ Rails Boost (44:10.906)

……….§ Build part of stack .. Custom rails … create your stack on options

……….§ Don’t take away ‘rails foo’ experience

• Q&A (45:54.318)

…..○ Rails 3 release?

……….§ When its ready. Not prior to google summer of code. 2-3 months after that.

……….§ Get more plug-ins ready … goal stables are more stable

…..○ Will you do something like Rails Boost (48:2.728)

……….§ DHH is against a bunch of questions

…..○ Ease up upgrade from 2.3 to 3 (49:43.843)

……….§ API focus (don’t break that)

…..○ Help

……….§ Run apps and plugins on Master

…..○ Will rails 3 work 1.8.6 ruby … yes

…..○ Rails 3 trunk .. Is available (github)

…..○ Any alpha versions? Beta releases … maybe.

…..○ Books on rails 3? Later.

The following article was written by Chris McCauley who kindly gave his permission for it to be published here.

I discovered one big gotcha while integrating Bunny with Merb and wanted to share the solution.

The background to this is that my company uses clusters of Merb and Rails processes to implement data validation services. Until recently our solution for monitoring the Merb part of the infrastructure was pretty manual, reactive and time consuming. I wanted a simple way to gather stats from Merb processes in the cluster and correlate them with activity on the host server and to do this over time. I also wanted email alerts to be sent when a request fails to meet its response target.

I thought that message queuing might offer a good solution, allowing the aggregation of the request data and the production of reports to be done with the minimum impact on the actual Merb processes. The idea was that each process in the cluster would publish the timing information for requests to a queue and a separate profiler process would handle the graphing and alert functionality.

I chose Bunny as the interface to RabbitMQ because it was synchronous. Although we use EventMachine to great effect elsewhere in our solution, it was a poor fit with the Merb architecture so the tmm1-amqp gem wasn’t really an option.

I figured that this would be a simple implementation – Merb uses Rack internally and provides access to the Rack framework via a “rackup” file. This provides a way to insert custom code into the request processing chain – in effect adding your own middle-ware into Merb. Profiling and monitoring is a middleware service so integrating Bunny and Rack here was the obvious choice.

The structure of a rackup file is very simple. The basic rackup file that Merb uses is…

# use PathPrefix Middleware if :path_prefix is set in Merb::Config
if prefix = ::Merb::Config[:path_prefix]
  use Merb::Rack::PathPrefix, prefix
end

# this is our main merb application
run Merb::Rack::Application.new

… this passes the inbound request straight to Merb for processing. To add custom middle-ware into the chain, you simple require your code and “use” it…

require 'bunny_profiler'

# use PathPrefix Middleware if :path_prefix is set in Merb::Config
if prefix = ::Merb::Config[:path_prefix]
  use Merb::Rack::PathPrefix, prefix
end

#  an interface to RabbitMQ via Bunny
use BunnyProfiler

# this is our main merb application
run Merb::Rack::Application.new

Obviously the “use” can be conditional, running in test environments but not production environments, on Tuesdays but not Thursdays etc.

Each rack file is simple, apart from the constructor it has only one method called ‘call’ which gets invoked in response to an inbound request. Since the call method gets a copy of all of the request headers, I figured that code as simple as this would work…

def call(env)
  status, headers, body = nil, nil, nil

  request_path  = env["REQUEST_URI"]
  request_input = env["rack.input"].read

  #  Call the next Rack app in sequence.
  #  Given our rackup file, this really means
  #  call our application and get it to
  #  process the request
  tm = Benchmark.measure {
    status, headers, body = @app.call(env)
  }

  #  Note that the pid of the sending process
  #  is part of the message
  #
  @queue.publish("#{Process.pid}” + “|" +
                            request_path    + "|" +
                            request_input   + "|" +
                            (tm.real).to_s)

  # This is the response required by Rack
  [status, headers, body]
end

The constructor is even simpler, we just set up a queue …

def initialize(app)
  @app = app

  @bunny = Bunny.new

  @bunny.start

  @queue = @bunny.queue('clavis.requests')
end

In the call method we measure how long the main application code takes to process the request and then to send this to RabbitMQ. Each process in the cluster sends to the same queue and a single client process aggregates the data, produces graphs and sends any alerts required.

When I deployed this solution in the test environment, all was fine, graphs got produced, email alerts got sent. When I deployed it to one of our production servers, all was again fine – for nearly a full day anyway.

Then one-by-one each server in the cluster locked-up. When I checked the server log files, it became obvious that under heavy load, the calls to publish messages to the queue were failing. A quick check of the RabbitMQ log showed the following;

=ERROR REPORT==== 14-Aug-2009::16:00:34 ===

connection <0.18759.12> (running), channel 1 – error:

{amqp,command_invalid,

“expected content header for class 60, got non content header frame instead”,

none}

This isn’t a particularly user-friendly error message. After some digging, I knew that this was somehow related to multiple messages being interleaved on the same channel causing RabbitMQ to close the socket connection. It seemed like a threading issues but I couldn’t see how my code could be wrong – it’s copied from the Bunny sample code! I didn’t want to give up on the solution; the combination of Bunny, Rabbit and Rack just seemed to be such a great approach.

I had noticed one odd thing, RabbitMQ was seeing only one socket connection from all the servers in the cluster but I knew that each server was sending data – the messages being sent include the PID of the sending process. Perhaps Bunny was using a single connection to RabbitMQ and I needed to use some additional logic to handle that situation? I figured that there was nothing else for it but to try and contact the Bunny maintainer, Chris Duncan

Chris was a great help. He confirmed that there’s nothing in Bunny which could cause the same connection to be reused by all the servers but perhaps I could look at the use of different channels for each server as well as turning on the Bunny debug log.

Odd as it may seem, it was the second suggestion – turning on the log file which provided the big clue. Since turning on logging is part of the initialisation step (for me anyway), I changed the initialize method to be …

def initialize(app)
  @app = app

  @bunny = Bunny.new

  @bunny.logfile = "/var/log/bunny-#{Process.pid}.log"

  @bunny.logging = true

  @bunny.start

  @queue = @bunny.queue('clavis.requests')
end

… and restarted all of the servers in the test cluster. My idea was that I would try and reproduce the problem in the test environment by sending as many requests at the same time as possible and by brute-force, make the problem reoccur.

I didn’t get that far, I noticed that only one log file was getting created instead of the twelve that I was expecting. That really looked like only one Merb process in the cluster was initialising Bunny – but I knew (from the reports getting produced) that each process was sending data. This was a contradiction – how could only one process have initialised Bunny yet all of the processes be sending messages?

The explanation was that only one process was actually initialising Bunny and because of the name of the log file I knew which one it was – the Merb spawner process. The spawner process was opening the socket connection to RabbitMQ via Bunny, then forking the child processes and since children inherit the socket connections, each process was sending on the same channel and on the same socket. Sooner or later two messages would get interleaved and RabbitMQ would drop the connection.

The solution was simple, I moved all of the initialisation code out of the constructor and introduced a new start_bunny method which did essentially the same thing and called this like so …

def call(env)
  status, headers, body = nil, nil, nil

  request_path  = env["REQUEST_URI"]
  request_input = env["rack.input"].read

  tm = Benchmark.measure {
    status, headers, body = @app.call(env)
  }

  start_bunny unless @queue

  @queue.publish("#{Process.pid}” + “|" +
                            request_path    + "|" +
                            request_input   + "|" +
                            (tm.real).to_s)

  [status, headers, body]
end

Now each process in the cluster initialises Bunny as required. Since the socket connections are distinct, it’s safe to use the default channel. Testing showed multiple connection requests going from Bunny to RabbitMQ – something which Chris had been expecting and multiple log files being created – which I had expected. More importantly, ten thousand requests later, the problem hasn’t reoccurred.

Introduction

While in the early requirements phase of a new open source project, I was wanting to encourage discussion on the database schema and web API. So I wrote some rspecs to capture the models, their attributes, and their relationships. As we played around with the schema, it was difficult to manually keep the specs accurate, particularly with the relationships. So I wrote a script to generate a merb project from the rspecs to catch relationship problems. This was good and also let me generate model and controller diagrams using railroad_xing.

After a few iterations I was happy and ready to add a little test data so I could play with the RESTful routes as the web API. I was still reluctant to give up the flexibility of generating the project directly from the rspecs, so after a couple of iterations, ended up with two features: first having a files/directory that is copied over the generated project; and second preserving changes by using git and generating the project on a branch then rebasing back to the master branch.

The first feature is simply to recursively to copy the structure in a files/ directory to the project directory after generation. The provides replacement and addition capabilities. Actually most of this stuff (rest controller,…) might ought to be refactored into slices.

One note on the RESTful route generation, it is limited to a depth of 2 (ex: /foos/1/bars/3) because the complexity of my original database would cause route compilation to run out of memory when the depth was set to 3. You can edit the config/router.rb as needed. And yes, the script replaces the normal merb generated controllers and views with ones that support REST, although the views are geared more towards debugging than a final product.

Installation

1. Install git on your system (http://git-scm.com/)
2. Install ruby on your system (http://www.ruby-lang.org)
3. Install rubygems on your system (http://www.ruby-lang.org/en/libraries/)
4. Update rubygems (gem update system)
5. Install SQLite3 on your system (http://www.sqlite.org/)
6. Optionally install ImageMagick (http://www.imagemagick.org) recommended
7. Optionally install Curl (http://curl.haxx.se)
8. Optionally install RestClient (http://rest-client.googlecode.com)

Now you have a choice, either just install the gem with:

gem install royw-spec2merb

or clone the repository:

1. Change to the directory where you want to keep your repositories
   (ex: cd ~/views)
2. Clone the repository (git clone git://github.com/royw/spec2merb.git)
   If you are intended to commit changes to the spec2merb, then fork it
   and clone your fork instead.
3. Change to the repository directory (cd spec2merb)
4. Install required gems (refer to or run the install file)

So let’s generate a project

First there will be two “project” directories:

• A project definition directory which will contain the spec/, and files/ directories used to create the merb project. This should be under version control.
• The created project directory which will be a git repository with two branches: ‘master’ and ‘generated’.

The basic work flow will be:

1. Create the project definition directory.
2. Create the defining spec in the definition directory
3. Run the script to create the merb project.
4. Rebase master from generated branch.
5. Refine the spec until the created merb project runs
6. Examine the generated diagrams and classes
7. Edit the spec and repeat the creation until you are satisfied
8. Proceed with normal web app development on the ‘master’ branch.

As you can see from the work flow, all we are doing is adding a few iterations of using the project generation tools to a normal work flow. The goal being to spin the project quickly, see what you got, then refine it until you are satisfied.

So let’s get started (note, this example is located in examples/addressbook).


cd ~/views
mkdir addressbook-definition
cd addressbook-definition
mkdir spec
vi spec/addressbook-db-schema_spec.rb


And type into addressbook-db-schema_spec.rb:

# This is a stub used to attach information about a model to the spec.
def synopsis(*args)
end
# NOTES
# * NVARCHAR should be used for fields that can contain non-english content.
# * Database should be configured for Unicode
describe("Locationbook Database Schema") do
  describe("Person Model") do
    synopsis("This model describes a person in the address book")
    # attributes
    it "should have a name [TEXT]"
    it "should have a honorific [NVARCHAR(4)]"
    # relationships
    it "should have a relationship of zero or more companies [has 0:n Company]"
    it "should have a relationship of zero or more locations [has 0:n Location]"
    it "should have a relationship of zero or more phones [has 0:n Phone]"
    it "should have a relationship of zero or more emails [has n Email]"
    # additional required methods
  end
  describe("Company Model") do
    synopsis("This model describes a company or business in the address book")
    # attributes
    it "should have a name [NVARCHAR(255)]"
    # relationships
    it "should have a relationship of zero or more people [has 0:n Person]"
    it "should have a relationship of zero or more locations [has 0:n Location]"
    it "should have a relationship of zero or more phones [has 0:n Phones]"
    it "should have a relationship of zero or more emails [has n Email]"
    # additional required methods
  end
  describe("Location Model") do
    synopsis("This model describes a mailing address or location.",
                  "Note a bug in datamapper is letting me use the name that I would prefer, 'Address'")
    # attributes
    it "should have a street_location (including apt or suite number) [NVARCHAR(255)]"
    it "should have a city [NVARCHAR(80)]"
    it "should have a state [NVARCHAR(2)]"
    # relationships
    it "should have a relationship of zero or more people [has 0:n Person]"
    it "should have a relationship of zero or more companies [has 0:n Company]"
    # additional required methods
    it "should return the full mailing location"
  end
  describe("Phone Model") do
    synopsis("This model encapsulates phone numbers")
    # attributes
    it "should have a number [NVARCHAR(14)]"
    # relationships
    it "should have a relationship of zero or more people [has 0:n Person]"
    # it "should have a relationship of zero or more companies [has 0:n Company]"
    # additional required methods
    it "should return the area code"
    it "should return the exchange"
  end
  describe("Email Model") do
    synopsis("This model encapsulates email addresses")
    # attributes
    it "should have an location [NVARCHAR(255)]"
    # relationships
    it "should have a relationship to a person [has 1 Person]"
    it "should have a relationship to a company [has 1 Company]"
    # additional required methods
    it "should return the account (ex: return 'foo' when location is 'foo@bar.com')"
    it "should return the host service (ex: return 'bar.com' when address is 'foo@bar.com')"
  end
end

As you have probably guessed, the String parameter to the it() method has some key structures:

• “should have” denotes a model property
• “should have a relationship” denotes an association
• “should reference” denotes a belongs_to or a has 1 relationship
• “should … variable_name [...]” or “should … variable_name (comment) [...]” defines the variable name and an optional comment. The comment will be appended to the corresponding generated code.
• what is in square brackets are database types (see lib/model_editor::to_dmtype for supported SQL types) or relationship types (has 1, has n, has 0..n, belongs_to). The format is “[relationship model]” where the model is the class name of the model the relationship is with (see lib/spec2_merb::it for parsing details)

Any it “…” line that does not match the rules is added as a comment to the model’s class.

The observant may have noticed that I commented out the company relationship in the Phone model. That’s on purpose to demonstrated missing half of a relationship a little later.

OK now that we have a spec, let’s generate the project:

spec2merb --project addressbook --spec spec/addressbook-db-schema_spec.rb


Hint, I like to put the above command line in a build script file so I don’t have keep retyping it…

It is a good practice to look carefully at the output for any error messages. If you see any, then you can change the spec and generate again.

In this case the generation succeeds. So first do a rebase:


cd addressbook
git rebase generated master


then fire up you favorite SVG viewer (I use Firefox for viewing and GIMP for printing) and open up the generated doc/models.svg (if you have ImageMagick installed, then you should also have a doc/models.gif):

Models Diagram Missing Phone Relationship to Company

Notice that the CompanyPhone join model only has one connection to Company and none to the Phone model. So go back and uncomment the company relationship in the Phone model spec and regenerate. This time the models diagram should look like:

Models Diagram

Looking good, but does it work?

Smoke Test Time

Change to the generated project directory and fire up merb

cd addressbook
bin/merb


Now fire up your browser and look at http://localhost:4000

No route defined for /

While the script defined the rest routes, it did not define the home page route. You can add the home page at the end of config/router.rb. The title is the project name and the menu bar is the set of controllers (defined in config/init/app_config.rb). For now click on People, Companies, Locations and you should see:

Addressbook showing history

At the bottom of the page is the history navigation.

Fire up your curl and get the people index:


curl -H "Content-Type: text/xml; charset=UTF-8" http://localhost:4000/people.xml


Still not very interesting without any data.

Add Some Data

So let’s add some data via rest using curl. Note you may prefer using a rest client like the one at http://rest-client.googlecode.com

Let’s create a work area in the project definition directory:


mkdir rest-requests


Now create the request xml by adding the following to rest-requests/add-person.xml:

<person>
  <name>Roy Wright</name>
  <honorific>Mr.</honorific>
</person>

And lets run it:


cd rest-requests
curl -H "Content-Type: text/xml; charset=UTF-8" --data-binary @add-person.xml http://localhost:4000/people.xml


And look at the data again:


curl -H "Content-Type: text/xml; charset=UTF-8" http://localhost:4000/people.xml


which should return:

<people type='array'>
  <person>
    <id type='datamapper::types::serial'>1</id>
    <name type='datamapper::types::text'>Joe Bob</name>
    <honorific type='datamapper::types::text'/>
  </person>
</people>

From Spec to Web Service

Wow! What we have just done is created a web service directly from specs! As a bonus we have a primitive HTML interface too.

Now admittedly all we have really done is exposed our models via REST. We will probably want to add code to have the interface do something.

Adding Code

Simply edit away on the master branch. When you find you need a change in the database schema, simply commit your master branch, edit the db schema spec, regenerate using spec2merb, then rebase the generated branch back to master.

Conclusion

Overall I think the experiment is showing promise by defining the database schema in one location in a readable format (rspec). Also by using git rebasing to extend using the merb generators over the entire project life is a major benefit.

Where Next?

I like the simple rspec organization of: it “should…” statements. These are pretty easy for anybody to grasp. At the same time I do not like imposing structure on the string. I’m thinking of extending the rspec DSL by adding a shall() method that would let me pass in the line to put in the model, something like:

def shall(comment, model_line)
  'should ' + comment
end

describe('Foo Model') do
  synopsis('This is an example model')
  it shall('have a name attribute', 'property :name, String, :length => 40, :unique => true')
  it shall('reference several bars', 'has n, :bars, :through => Resource')
end

Currently both sides of a relationship must be specified. It would be nice to only have to spec a relationship once. I’m not sure the best way to accomplish this as having the relationship defined in the model seems most natural and all I can think of is to have a separate describe block for all of the relationships. Thoughts?

Finally what other parts of the application can we spec? Maybe whether or not to use RESTful vs. ad hoc routes? Maybe more on the views? Ideas?

Have Fun,
Roy

Just a side note…

Have you heard about Rails 3.0:

• The day Merb joined Rails
• RailsConf 09 – DHH – The Secret of Productivity
• Stop worrying and start loving Rails 3
• Rails and Merb better together?
• Let’s Be Clear: The Rails Monoculture Is Over

What about its effort to be ORM agnostic?

http://yehudakatz.com/2009/01/06/another-dispatch-step-1-of-2-complete/

“[...] Lori has been working hard on the ORM adapter for Rails. Effectively, the adapter will work like: ActiveORM.for(@sequel_obj). If the object is compatible with the ActiveORM API (note that the names et al are still very much in flux), it will be passed through. For instance, ActiveORM.for(@ar_obj) will just return the ActiveRecord object. ActiveORM.for(@sequel_obj), however, will return a wrapper around the object that is compatible with Rails expectations. Example: ActiveORM.for(@sequel_obj).new_record?. Note that this paragraph is speculative and represents work that is still very much in flux. [...]“

I believe that the whole thing might help us doing some “DDD on Rails”.

Olá,

Ontem eu assisti excelentes palestras on-line do Café com TOM. Para quem não conhece o Café com TOM é o oferecido gratuitamente pela e-Genial. Se você não pode acompanhar as palestras on-line, você pode baixar a gravação delas quando quiser, é o que eu geralmente faço. Posso dizer que a qualidade da gravação é muito boa.

Alias o Café com TOM usa o Treina TOM, uma excelente ferramenta colaborativa de ensino a distância, desenvolvida pelo própria e-Genial.

Gostaria de parabenizar a e-Genial por esse magnífico trabalho com o Treina TOM e Café com TOM.

Bom pra finalizar, não deixem de conferir as palestras do Café com TOM. Lá você irá encontrar palestras de RSpec, Merb, BlazeDS, entre outras.

Abraços,

Leo

Yesterday I took Merb for a small test drive, a customer of mine asked me to develop a custom case management system and I decided to try out Merb.I have to say, I really like Datamapper compared to ActiveRecord, not that it’s all that different, but I like being able to see the properties by opening a model. I know datamapper and activerecord can both tbe used with Merb and that datamapper is not a part of Merb.

The command line tool is also a bit different, instead of script/generate controller you have merb resource which is quit nice as well.

Earlier today, I was checking out the suggested connections provided by re-searchr (by James Ostheimer, @jostheim).  A discussion arose around ranking suggested users and potentially using a measure like TunkRank as a part of that ranking.  The prospect of James having to reimplement TunkRank encouraged me to implement a part of the TunkRank API I had been planning for a while:  fetching a user’s TunkRank score.

Fortunately, Merb is a framework that makes it particularly easy to render a page in different formats without having to add a lot of new code.  The end result is a very simple first step that returns the raw TunkRank score in JSON format.  You can access it via the following RESTful url:

http://tunkrank.com/twitter_users/{username}.json

If the user has not had their TunkRank score calculated yet, the return value will be 0, otherwise it will be a number greater than or equal to one. New users are added to a queue and are ranked at various points throughout the day when usage is low. It’s on my TODO list to make this happen more frequently. I can only blame its neglect on forgetfulness.

Daniel already has a write-up on this fledgling API. I’ve been busy watching the first week of In Treatment on DVD — a show that is turning out to be very intriguing. I realize that has nothing to do with the rest of the post, but I liked the show so much I had to tell someone.

Bueno la verdad que es todo un acontecimiento, los desarrolladores de Merb y los de Rails, los dos frameworks ruby con más aceptación, van a unir sus fuerzas y crear un unico framework en su siguiente versión principal. Tendremos por lo tanto que Merb 2 = Rails 3.

Con un artículo titulado Merb gets merged into Rails 3!, David Heinemeier hace un resumen de cuáles son sus expectativas:

Rails será más modular. De forma análoga a Merb, al construir una aplicación con Rails se podrá partir de un “rails-core” e ir añadiendo funcionalidades a medida que sean necesarias. Así no mataremos moscas a cañonazos.
El rendimiento es otro área en el que puede haber mejoras sustanciales ya que este es un aspecto en el que los desarrolladores de Merb han invertido mucho esfuerzo. De hecho, han reescrito partes de Rails con ese objetivo en mente, así que su experiencia en este sentido tiene mucho valor. Además, no les temblará la mano a la hora de modificar la arquitectura donde sea necesario.
Rails 3 será “agnóstico”. La idea es que los desarrolladores puedan elegir entre diferentes ORMs (ActiveRecord, Sequel, Datamapper…), plataformas de pruebas (test unit, RSpec…), bibliotecas para AJAX (JQuery, Prototype…), otros lenguajes para plantillas como Haml, etc.
Otra cosa que a Rails le falta es una API estable y clara para aquellos que desean desarrollar plugins. Según admite el propio Heinemeier, eso lleva a que al actualizar Rails se “rompan” muchos de estos plugins. Merb cuenta con una API estable cubierta con baterías de pruebas para minimizar estos problemas.
Por su parte, Yehuda Katz, desarrollador de Merb, también comparte sus impresiones en su artículo Rails and Merb Merge. Pero creo que lo más destacable es su promesa de no “dejar tirados” a aquellos que están usando Merb hoy en día. Creo que la intención se puede resumir en esta afirmación suya: Merb 2 es Rails 3.

A couple months ago, Daniel Tunkelang posted an algorithm on his blog that attempts to emulate PageRank for Twitter.  I implemented a toy version I dubbed TunkRank, and then suggested that name on his blog.  It got some traction, so I figured what the heck and decided to implement it on TunkRank.com.

Now, there appeared to be a little debate about just whether it is actually emulating PageRank or something else on Daniel’s blog, but I leave it to you to read the comments  on his post if you’re interested. There are also plenty of ideas there on the best way to establish a measure of influence.  I’ll limit the discussion in this post to the basics.

1. The amount of attention you can give is spread out among all those you follow. The more you follow, the less attention you can give each one.
2. Your influence depends on the amount of attention your followers can give you.

As a twitterer, your influence does not depend on how many people you follow. However, your usefulness as a follower does. Having higher influence depends on having many followers who follow relatively few people but are followed by many. Followers like that are more likely to pick up on your tweets, act on them, retweet them, whatever. You gain influence through the social graph thanks to their influence.

Therefore, your TunkRank score is a reflection of how much attention your followers can both directly give you and give to you.

I implemented this algorithm in Ruby using Merb, MySQL, Capistrano, nginx, and ActiveRecord (and, of course, Git for version control). While my job involves working on a web app, my role has mostly been on back-end NLP stuff. I’m still quite new to the whole Rails-level-web-app-world. For those who don’t know, Merb is a framework similar Ruby on Rails. So similar they are merging and will become Rails 3. ActiveRecord is an Object-relational Mapping (ORM) that Rails uses. The standard ORM for Merb is DataMapper, but I stuck with something I’m more familiar with to limit the variables in my little project.

There are many aspects of getting a web app up and running that I had only heard about in passing — and many more I’m still lost on. But I figured implementing TunkRank would be an interesting place to start.

Phase I – Data Collection

As I said, I implemented TunkRank as a toy the same night that Daniel posted his algorithm. Things seemed to work out quite nicely and I liked it on theoretical grounds as a measure. When I decided to implement the real version, the task of hammering Twitter millions of times suddenly loomed. I suppose I thought there were maybe about 1 million active accounts on Twitter. I have harvested over 2 million before slowing my harvesting down in favor of other development. I have also collected about 40 million edges in the social graph (user A follows user B is one edge). Of the 2 million users I have encountered, those 40 million edges are for only 25% of them. I still haven’t gotten the followers for the remaining 1.5 million. When I do so, I’m sure I’ll discover another million or three users I haven’t seen yet.

I stopped where I did because I was using Ruby’s marshal functionality to dump the social graph to disk. Each dump was weighing in around 250 MB and it was exceeding Marshal’s ability to function. At this point I threw everything into a MySQL database. Bleh! I can’t even describe the pain in the ass that was. If I were to do that again, I would certainly use PostgreSQL, and may still do so. Better yet, I would use some sort of column store database.  But it’s in the MySQL db now and running ok (just ok, not great or even well). MySQL dies quietly and annoyingly at times.  I hate it.

Doing the operations I was doing before in memory in ActiveRecord instead is mind-bogglingly slow by comparison, as you’d expect. Twitter just released the ability to pull all follower ids in one request, which would have made my life easier, but I still can benefit from it going forward. Also, I should have been storing more information about users than just the twitter username. Having to go back and collect that was slow and annoying, but it’s done.

Phase II – Implementing the Algorithm

The algorithm is simple to compute. Check out this gist for a version that calculates it using ActiveRecord. I’d post it here, but WordPress.com sucks and I’m stuck with it. The code uses ActiveRecord more than I’d like, so I rewrote it in SQL using twitter ids.  The gist for that is here.  The #{p} and #{self.twitter_id} are Ruby variables.

Phase III – Doing the Web App

The web app itself is both the most important step and the least fun for me. I very much enjoyed putting together the code to collect the Twitter social graph and then computing the TunkRank scores, but all the nuts and bolts of getting a web app up and running are tedious. Some of it is interesting. Merb isn’t so bad, though I feel like the documentation is shitty. There is an open source Merb book that is missing stuff in all the sections I needed the most. The API documentation isn’t bad, but isn’t easy to search for high level things that you would normally find in a tutorial. Nor should it be — it’s API documentation not a tutorial.

Fortunately, most things were easy enough that I could find a solution eventually. The whole deploying step is foreign to me, and I’m an apache noob so when it comes to balancing mongrel instances I’m like wtf?  Fortunately, I found a few tutorials I was able to piece together.

So the final product is hosted on my 1.8 GHz dual core Dell laptop with 2 GB RAM running Ubuntu 8.10. If you check it out, hopefully it won’t overtax my pathetic server and bring the site down. My data is becoming a little stale so if your username isn’t found, please be patient. When a new person is encountered, I queue them for processing.

Final Thoughts

You can also follow @tunkrank on Twitter. I originally had that account acting as a bot that tweets scores when it encounters influential users. Also,  I was having it auto-follow anyone it grades, but upon reflection, it occurred to me these two things were just plain spammy. I chalk it up to a bad decision in the dead of night. Instead I will just have it follow anyone who follows it.  See my twitter philosophy for how the account will be managed.  I will post updates there on changes, fixes, and up/downtime.

The TunkRank score itself can grow quite large, especially for users with a high number of followers. I present percentiles as the measure, so everything falls in the interval [0,100]. That does not properly reflect that someone in the 100th percentile can be almost 1000 times more influential than someone in the 99th. I’m open to suggestions about how better to show this information. Neal Richter had a few good ideas, perhaps I’ll try one of those.  Still, though, I’m left feeling a little dissatisfied by all of the scoring mechanisms (my own included). As Neal pointed out, his ideas are starting points and I’d like to hear what other people would like to see before proceeding with a different scoring method.

Let me know what you think.

Merb is Javascript agnostic and does not come with the many Javascript helpers

that Rails provides with the Prototype library. This means the level of understanding of Javascript needs to be higher using Merb to get things done.  At the recent Merb training class in Phoenix a fellow participant showed me the site Douglas Crockford has his Javascript tutorials posted.  I found them very good in presenting a solid foundation to build on when using Javascript. There is allot of other interesting background on Javascript in general posted there as well.

Just a couple of crumbs from my brush with Merb tonight:

dependencies.rb

After merb-gen app, edit config/dependencies.rb to fix version numbers of dm_gems_version and do_gems_version gems used by the generated app. To find out what which version you have, type

gem list {gem-name}.

Missing some MySQL dylib on OS X

When I got some errors like “dyld: NSLinkModule() error “, probably after doing sudo gem install do_mysql for reasons I can’t recall, I fixed it with this:

sudo mkdir /usr/local/mysql/lib/mysql
cd /usr/local/mysql/lib/mysql
sudo ln -s /usr/local/mysql/lib/*.dylib .

I’ll add to this post over time as more crumbs fall. Note that I am not a Merb, Rails, nor Ruby guy. I am not a guru in anything but everything which means exactly nothing. Yes, I am trying to confuse you. ;-p

Fabulous February started with a Live webcast from California. I agreed to my Invitation to attend the event. It was a wednesday (3/2/09)evening, when I had to review my Laptop for Java Updates and other stuffs for the event. The event was about to begin at 10PM and I launched  my browser and found Mr. Aruna Gupta, GlassFish Evangelist, Sun Microsystems, welcoming the session attendees. It was a great pleasure for me to  attend the Webinar and I thank Mr. Arun Gupta for his talk on GlassFish. I have blogged all about GlassFish which I have carried as notes after the session. I found GlassFish interesting and this Webinar has changed my Application Server from Apache to Glassfish in deploying all my scripts.

GlassFish is a vibrant community building high-quality, open source software. The main deliverable are the GlassFish application server, the Java Platform, Enterprise Edition(java EE) reference implementation, and the Java Persistence API reference implementation.

Developing Server based Application with the help of clear application specification of Java EE 5 helps us to deploy the application with 100% uptime. The Glassfish which is built on the Java EE compliance is portable. Java EE 5 has API, Technology specification, Production-quality implementation, Comptability Test Suite, themed on ease of development.Here POJO ( Plain Old Java Object) based programming gives us more freedom and fewer requirement in implementation level. The Latest inclusion DRY( Don’t Repeat Yourself) mechanism allows all the connection strings of the database from the application level to be kept in a songle file making debugging easier and faster access.

The latest Call Flow Monitoring allows us to enable the monitoring of the app server to track the time spent on the EJB Container, Web Container, and EJB Application and lots more enabling us to improve the performance. There is a special Request Time Distribution column showing the time spent on each requests.

GlassFish TimeLine

June 2005           -    GlassFish Launch

May 2007            -   Version 1 ( With Java EE 5)

Sept 2007            -   Version2

Nov 2008             -   Prelude

Jan 2009              -   Version2.1 (latest)

In Jan 209 500 bugs were fixed to improve stability and it was Java EE 5 Compliance supporting JSP,Servlet, EJB and lots more.

Certainly Interesting Stats on Glassfish :  GlassFish Usage Map

GlassFish also supports dynamic Languages and framework like JRuby, Merb, Rails, Ruby, Groovy, Grails, Python, Jython, django, JavaScript and lots more. Quercus should be used for deploying PHP apps in GlassFish.

I’ll chart the “To Do” steps to install GlassFish and Deploy it in your Local Machine…

Steps to Deploy GlassFish in your Machine

—>Download GlassFish V3 Prelude

—>Unzip GlassFish-V3-Prelude-V28C.Zip

—>Start: asadmin start domain

It is very simple to install and deploy the Application Server.

We can access the admin console @ http://localhost:4848/

and deploy our applications @ http://localhost:8080

Some of the Cool Features in GlassFish V3

—>It can retain session data across HTTP deploys

—>Embeddable- Runs in -VM

—>Supports Dynamic Languages

—>Fastest Start/up Time-2-3 Seconds

—>Support World Class IDE’s such as NETBEANS 6.5 and Eclipse

—>Extensible, Modular, ease to use

—>Failover Administration, monitoring, messaging, Persistence

Plan for GlassFish V3

GlassFish v3 is the next major release of the GlassFish Application Server and is currently under development by the GlassFish Community. GlassFish v3 has a modular, lightweight, extensible architecture. The goals are to provide the following:

• An open, modular, extensible platform
• A fast, easy, reliable application server
• An enterprise-ready application server with massive scalability and sophisticated administration
• Product updates and add-ons through the industry-strength
• Support for OSGi
• Support for dynamic languages such as Ruby and Groovy
• Support for Java EE 6

I consider GlassFish as an excellent alternative to lesser featured Tomcat and JBOSS. Netbeans 6.5 comes with GlassFish V2 and V3 bunduled, which makes developing and deploying application easy and effective. GlassFish is the Fastest Open Source Application sever. So from Student to Enterprise, I recommend GlassFish as the Best Application Server for all your Web Apps.

Tech Talk by Arun Gupta on Ruby/GlassFish

Sun Microsystems hosted the 30th Super Happy Dev House at it’s Executive Briefing center in Menlo Park, CA. Over 300 super smart developers gathered to geek it out on the next generation of technologies. During the Lightening Talk period, Arun Gupta (Super Technology Guru Extraordinaire from Sun) talked about Ruby and GlassFish. He ran out of time before being able to showcase Project Kenai, built using Ruby-on-Rails, JRuby, GlassFish, MySQL, and OpenSolaris

For More Learning on GlassFish:

One Stop:   glassfish.org

Student:   spotlight.dev.java.net

Wiki:        wiki.glassfish.java.net

Source Code Repository: glassfish_svn.dev.java.net

Blog sphere:  blogs.sun.com/theaquarium

剛剛發生的問題

Merb啟動後對url都有反應(從console看的)，但是browser卻沒收到任何資料

Google一下，在這裡發現了解法

http://www.raecoo.com/2008/12/18/upgrade-merb-cause-nothing-to-render/

結論就是merb-action-args有bug

請把它從dependencies.rb註解掉