Design Patterns in Ruby documents smart ways to resolve many problems that Ruby developers commonly encounter. Addison-Wesley Professional press has this exciting book, authored by Russ Olsen.

Russ Olsen has done a great job of selecting classic patterns and augmenting these with newer patterns that have special relevance for Ruby. Most design pattern books are based on C++ and Java. But Ruby is different—and the language’s unique qualities make design patterns easier to implement and use.

In this book, Russ Olsen demonstrates how to combine Ruby’s power and elegance with patterns, and write more sophisticated, effective software with far fewer lines of code.The book especially calls attention to Ruby features that simplify the use of patterns, including dynamic typing, code closures, and “mixins” for easier code reuse.

Design Patterns in Ruby also identifies innovative new patterns that have emerged from the Ruby community. These include ways to create custom objects with metaprogramming, as well as the ambitious Rails-based “Convention over Configuration” pattern, designed to help integrate entire applications and frameworks.

More resources:

• “Design Patterns in Ruby” at Amazon.com
• Review at barnesandnoble homepage

No related posts.

Related posts brought to you by Yet Another Related Posts Plugin.

RM-Manage is a monitoring product for Rails applications. Their claim:

Building elegant and powerful Rails applications rapidly is important. Ensuring that they perform properly once deployed in production is even more important. A poorly performing or unavailable business-critical application can have a devastating impact on your bottom line, negating the benefits of Rails development.

Rails applications are more than just Rails itself. Databases like MySQL and Oracle, web servers such as Apache, and even the host operating system each affect performance and availability.

Although you may have done a great job designing a well-behaved Rails application, the fact is you won’t know how well it will truly perform until you monitor and respond to it in production. RM-Manage wraps the task of monitoring your applications in a simple and affordable interface.

Application Browser

The Application Browser for Rails allows you to view and filter important performance metrics for your production Rails applications. The application browser quickly gathers collected Model, View and Controller statistics such as averages, slowest and fastest performing models or views and more making it easy to explore application problems and bottlencks.

Screen Highlights

1. Browse and select a particular system and production Rails application for which to view performance metrics.
2. See a full list of actions in the selected application grouped by their respective controllers. Select an action to see all its related MVC information.
3. Take a closer look at the amount of time spent in the controller, model and view layers.
4. Filter method invocation information by the model, view or controller layer to see common metrics such as average, slowest and fastest invocation times, ordered by severity for the currently selected filter.

As your applications evolve and expand, you will encounter performance and availability problems. How will you troubleshoot and accurately diagnose these issues? How will you know for sure if the problem is a bug, a memory leak, a database connection issue, or a design issue? How will you ensure performance and uptime?

RM-Manage is the first and only Rails application monitoring product to instrument and monitor all aspects of the Rails framework and its supporting infrastructure resources.

RM-Manage makes it easy to design your Rails applications for optimal performance and reliability. Define personalized views of performance data (timings, counts, errors, size) based on how you want to view your application. Use the other integrated monitoring services to provide you with all the tools you’ll need to troubleshoot your application and its underlying infrastructure.

Interested? Read more at FiveRuns’ site.

No related posts.

Related posts brought to you by Yet Another Related Posts Plugin.

Practical Reporting with Ruby and Rails is a great book for Ruby and Rails developers seeking to create compelling business intelligence and reporting solutions using a wide variety of applications and services. Published by Apress, and the author is David Berube.

Business intelligence and real-time reporting mechanisms play a major role in any of today’s forward-looking business plans. With many of these solutions being moved to the Web, the popular Rails framework and its underlying Ruby language are playing a major role alongside web services in building the reporting solutions of tomorrow.

Practical Reporting with Ruby and Rails is the first book to comprehensively introduce this popular framework, guiding readers through a wide-ranging array of features. Note this isn’t a staid guide to generating traditional reports, but rather it shows you how the Ruby language and Rails framework can create truly compelling reporting services by plugging into popular third-party applications and services such as Google AdWords, UPS.com, iTunes, and SalesForce.com.

There’s a lot to learn from this book, including:

• Create reporting solutions for both the Web and the desktop.
• Integrate with powerful third-party retail solutions such as eBay, and Amazon.com in order to monitor your sales campaigns in real-time.
• Build an invoice reporting system using Rails and PayPal.
• Monitor your sales performance by taking advantage of SugarCRM’s web service offerings.

More resources:

• Editorial review at Amazon.com

No related posts.

Related posts brought to you by Yet Another Related Posts Plugin.

You know what, I really wanna learn this whole JavaEE-related thingy……

For some reason it’s unavoidable……. it’s bound to be touched by me……

You see, the trend is going RIA. MVC is going away. AJAX ain’t gonna compete. At least not fully. And will lose in many ways in respect to something like Adobe’s Flex. (Unfortunately there’s not much competitor better than Flex, and fortunately it’d probably be “standard” in the near future). Esp. with Flex going open source. Flex will need a backend, since it’s not a server-side product. There is Flex LiveCycle Data Services ES (what a name!!) by Adobe. There’s also BlazeDS open source. There’s also the excellent WebORB, which is free and open source for Rails and PHP. Oh yeah, it’s free for Rails!

Sure you can go with plain Rails, but it’s maybe too much work, when WebORB already does it for you.

This is wonderful, but it only gives you plain RPC. It’s traditional (legacy?) synchronous RPC camouflaged as “asynchronous”.

Real asynchronous power comes from Messaging. And the buzzword is now Comet. The latest Jetty already supports Comet technique, which can continuously “streams” asynchronous messages and data to (instead of being pulled) your client-side web UI… (that might just be a Flex app)

Simple messaging is fine, but the real power of messaging comes from features that had existed for a long time it’s actually legacy, such as publish/subcribe, message routing, and reliable delivery and timeouts. Fortunately, we have ActiveMQ, and yes we have activemessaging library for Ruby and Rails plugin.

Unfortunately messaging servers have different protocols. Although there are “universal” protocols like Stomp and AMQP (backed by RabbitMQ), you can also use an ESB like Mule or OpenESB or Apache ServiceMix if your component needs to talk to components with a different protocol. Oh yes they’re from the Java world.

Even as we’re embracing THE ActiveRecord, the Java community coming up with an also-cool solution called JPA, supported by all popular Java ORM tools such as Hibernate and TopLink; Microsoft strikes back with the invulnerable LINQ.

Yet we still have too many queued messages and database records to handle, we need to know how to make use of them. EDA comes to the rescue, like what Esper does. And of course BI and reporting tools such as JasperReports, Pentaho and Ruby’s Ruport.

We like REST’s simplicity over WS-* for enterprise-y SOA apps. Microformats is very nice with just a little Hpricot and Mofo goodness. And thanks to Mechanize or Scrubyt or openkapow and the good ole’ RSS, mashup is always getting easier. Let’s hope Atom’s APP really does take off as well. But sometimes we want more flexibility, we want BPM-powered workflow. No worries, we have JBoss’ jBPM. Our Ruby community also has OpenWFEru!

Everybody hates the login form, especially if it comes more often than we brush our teeth. We want SSO, be it CAS, OpenID, SAML, or plain LDAP (with OpenLDAP), we want it now.

And no, I haven’t forgotten Android, nor iPhone, nor Symbian, nor Windows Mobile. The mobile space is getting more, not less, fragmented. All because they know the market is growing. Everybody wants a pie. (me too!)

You’ve heard him. Not all startups are profitable. Especially not when we’re fighting with each other. The “enterprise”, and corporate, has money… (unfortunately not all of us do, no matter how much we [all] want it…)

Users are getting more demanding and demands are getting more complicated, so are the technologies. We probably should embrace these technologies and the people who work on them (whether paid or unpaid or voluntary or forced…!) more so than we criticize and demotivate each other.

Ruby is a great tool, and so is Java (JVM) and so is JRuby and its close mates like Groovy, Scala, Jython, and Rhino with ECMAScript 4 and E4X support. Some people are also starting to fall in love with Erlang.

Oh well… This isn’t a rant. It’s just a brain-dump from me. Hope somebody finds it useful. Good morning guys

UPDATE: Clarifications regarding WebORB and messaging protocols.

No related posts.

Related posts brought to you by Yet Another Related Posts Plugin.

Robert Thau from Smartleaf proposes a cool idea for implementing DSL for use in Active Record permissions. It makes it easy for a lot of users to have access rights and very exciting at the same time…

This is the Tease….

class Order < ActiveRecord::Base

  access_control_keys ['id', 'owner_id', 'paid']

  require_privilege :place,
    :for_action => :create,
    :to_update_attribute => [:payment_authenticator, :paid]

  require_privilege :edit,      # LineItem also checks this for attr changes
    :to_associate_as  => ['LineItem#order'],
    :to_dissociate_as => ['LineItem#order'],
    :to_update_attribute => [ :shipping_address ]

  require_privilege :ship,       :to_update_attribute => :shipped

  ...

end

 

The implementation:

• Data model
• Checking privileges: does user x have privilege y on this order?
• Finding all orders where user x has privilege y
• Adding privilege checks in interesting places…
  • On events: create, update…
  • On attribute sets
  • For associations

It’s just Ruby! Class variables and class methods:

• All declared privileges (for choosers in the UI)
• Dual-keyed hash: reflected_privilege[type][key]
• … e.g., reflected_privilege[:read_attribute][attr]
• … e.g., reflected_privilege[:associate][assoc_key]
• Class helpers (permits_update_attr?, etc.) just read the hash, and do the appropriate check.

Read more on:

http://www.smartleaf.com/rst/perm_present/perm_present.html

No downloadable code (yet), but still cool

No related posts.

Related posts brought to you by Yet Another Related Posts Plugin.

Just out is ActiveRecord-JDBC 0.6, the post-RubyConf release.

The sparkly new feature is Rails 2.0 support. In the soon-to-be-released Rails 2.0 (edge), Rails will automatically look for and load an adapter gem based on the name of the adapter you specify in database.yml.

let’s see the example:

development:

  adapter: funkdb

  ...

We can leverage this convention to make it easier than ever to get started using JRuby with your Rails application. So, the first thing new in the 0.6 release is the name. You now install activerecord-jdbc-adapter:

jruby -S gem install activerecord-jdbc-adapter

But wait, there’s more! We also have adapters for four open-source databases, including MySQL, PostgreSQL, and two embedded Java databases, Derby and HSQLDB. And, for your convenience, we’ve bundled the JDBC drivers in dependent gems, so you don’t have to go hunting them down if you don’t have them handy.

if you need to connect to a different database, you’ll still need to place your database’s JDBC driver jar file in the appropriate place and use the straight activerecord-jdbc-adapter. Also note that in this case, and for Rails 1.2.x in general, you’ll still need to add that pesky require statement to config/environment.rb.

As always, there are bug fixes too (though we haven’t been tracking exactly which ones are fixed). We’re starting to file ActiveRecord-JDBC bugs in the JRuby JIRA now, and will be putting in future AR-JDBC versions to target soon too. So, please file new bugs in JIRA (and select component “ActiveRecord-JDBC”) rather than in the antiquated Rubyforge tracker.

Read more on Nick Sieger’s blog.

Related posts:

1. NetBeans IDE 6.8 Released — with Enhanced Ruby on Rails Support! NetBeans IDE version 6.8 has been released, Sun Microsystems’...

Related posts brought to you by Yet Another Related Posts Plugin.

Any Ruby on Rails programmer would have touched Active Record, probably in a very early phase. Active Record deals with everything that’s related to the database of your Ruby on Rails applications, and in many ways a bit more.

Apress recently launched Pro Active Record: Databases with Ruby on Rails, which I can honestly say, is the most exhaustive, if not the only, book about Active Record I’ve ever known to date.

The book starts with a little bit of a “wow” factor, especially true if you’re new to Ruby on Rails: demonstrating the ease of use of Active Record itself. No configuration needed! Seriously, that’s not the claim of the book but it’s fact of Active Record: all you need is your database credentials and name of the table you want to work with. Everything else is almost magical.

The next sections deal with installing and configuring Active Record. I have to say sometimes (based on my own experiences) it’s not that trivial, especially on Windows. The book guides you through installing drivers/adapters for common and less popular DBMSes. OK, let’s name them: DB2, Firebird, FrontBase, MySQL, OpenBase, Oracle, PostgreSQL, SQLite, Microsoft SQL Server, Sybase, they’re all covered! I was wondering if I can connect to ODBC?

The second chapter deals with the “simple” things, namely, how to do SELECT, UPDATE, DELETE, INSERT, or what you cool guys usually call “CRUD”, the Active Record-way. This information is usually taken for granted, but it’s explained quite deeply in this book.

The next chapter guides you to design your tables so they work smoothly with Active Record. Although you can use legacy designs just fine with Active Record, your life will be much, much easier if you follow Active Record conventions. This book shows you just how, and in many cases, why.

Chapter 4 shows you how to use core Active Record features, including triggers and validations. If you’re asking that question, then the answer is yes, it’s almost completely overlapping with native but proprietary DBMS functionality such as PL/SQL, DBMS triggers, and constraints. The book doesn’t seem to explain much of this holy war, but I encourage you to ask Google why stored procedures are evil.

Chapter 5 gives you a view of Active Record “bonus features”. I think the chapter title is a misnomer because these features are not just bonus, but one of the greatest strengths of Active Record (compared to other ORM). Things like nested sets, lists, observers, aggregations, and little bit of extending Active Record: these are things that you’ll do, and use, daily — not something you try to avoid. They make your life as a DB integrator easier, not the other way around.

You want to make sure your app works fine, chapter 6 covers unit testing very thoroughly, down to the descriptions of errors (i.e. Active Record Exception objects) you may encounter.

If you already had a previous database, as most of us are, no worries, chapter 7 will guide you how to work with them. This is one of the most useful chapters in this book, because there is less information on the Internet on this topic, but it’s very common that everybody is bound to meet this problem. Come on, who actually learned Active Record before hearing the word DBMS?

The last chapter talks about issues that you’ll encounter in the “real world”, including alternatives and related enhancements to Active Record. What follows is the appendix, which is a really useful quick reference.

The book is really, really good. Full of core information, and related information that aren’t readily available even after asking Mr. Google a hundred times. Despite being written by 3 different developers: Kevin Marshall, Chad Pytel, and Jon Yurek; the entire book is nicely structured and feels cohesive. It will save you lots of time in times of frustration, you can look up the information much quickly here than does a search engine.

Interested already? You can get more information about Pro Active Record book on Amazon, and buy it there too of course. It’s also available on Apress official site.

Personal minor gripe, not a flaw, is there wasn’t a (detachable) cheatsheet. A poster-sized, deluxe exclusive cheatsheet would be a tremendous killer plus to this book. I really think Apress should make this kind of thing mandatory in the future, not only regular Appendixes.

Other resources related to this book:

• James Stewart’s review
• Inside Apress blog

No related posts.

Related posts brought to you by Yet Another Related Posts Plugin.

Just out from a pack of several of the world’s greatest Ruby and/on Rails programmers: Professional Ruby Collection: Mongrel, Rails Plugins, Rails Routing, Refactoring to REST, and Rubyisms.

GET STRAIGHT TO THE LEADING EDGE WITH RUBY AND RAILS

Information that’s so hot, new, and valuable, you can’t wait for a book. This package brings together 8 breakthrough primers on today’s most valuable Ruby and Rails technologies — including five new digital Short Cuts worth $69.95! From RailsSpace to ActiveRecord to Mongrel, here’s new content, techniques, and code from the Ruby community’s top innovators: insider’s information that’s never been available before in one place.

<br />On the CD-ROM: 5 brand-new digital Short Cuts…

• Mongrel: Serving, Deploying, and Extending Your Ruby Applications, by Matt Pelletier and Zed Shaw
• Rails Plugins: Extending Rails Beyond the Core, by James Adam
• Rails Routing, by David A. Black
• Rails Refactoring to Resources: Using CRUD and REST in Your Rails Application, by Trotter Cashion
• Rubyisms in Rails, by Jacob Harris

PLUS, PRINTED BONUS CONTENT INCLUDES

• Working with Active Record (from the forthcoming Addison-Wesley book The Rails Way by Obie Fernandez)
• RESTful Blogs (from RailsSpace by Michael Hartl and Aurelius Prochazka)
• OOP and Dynamic Features in Ruby (from The Ruby Way, Second Edition, by Hal Fulton)

About the Authors

• Matt Pelletier (WorkingWithRails profile) is a partner at EastMedia, a software, mobile, and business development firm. He is also cofounder of NYC.rb, the New York City Ruby group.
• Zed Shaw (WorkingWithRails profile) is the original and primary author of Mongrel.
• David A. Black (WorkingWithRails profile) is Director, Ruby Power and Light, LLC and also Co-Director, Ruby Central, Inc. He is the bestselling author of Ruby for Rails.
• Trotter Cashion (WorkingWithRails profile) is an application developer at motionbox.com, a Rails-based video sharing site.
• Dr. James Adam (WorkingWithRails profile) is the developer behind the Engines plugin.
• Jacob Harris (WorkingWithRails profile) is a web developer for New York Times Digital.

Enough said!

No related posts.

Related posts brought to you by Yet Another Related Posts Plugin.

Some people asked me about SVK so here it is. Quickly written because I am a bit lazy and sleepy right now.

SVK is a distributed version control system. In other words, it allows you to mirror a Subversion repository, have local commits, pull changes from upstream, and synchronize/merge it back to the remote Subversion server if you want.

English version

UPDATE: This is an outdated version. The most up-to-date version with newer tips and tricks is in wiki Ruby Indonesia: SVK, which unfortunately is only available in Indonesian.

Method 1: Use Subversion repository, but SVK working copy

Assumptions:

• Subversion repository remote: http://svn.example.com/try/
• SVK depot: /try/

svk depot try ~/.svk/try
svk mirror /try/remote http://svn.example.com/try/
svk sync /try/remote
svk cp /try/remote /try/local

Checkout & working copy:

svk co /try/local/trunk

Commit:

svk ci

Push: (merge to remote)

svk push

Pull: (merge from remote to local)

svk pull

Method 2: Use remote Subversion repository, local Subversion repository, and SVK to merge between those repositories

The advantage of this approach is that you can use usual Subversion tools (TortoiseSVN, or native utility from Aptana IDE, NetBeans, etc.)

Assumptions:

• Subversion repository remote: http://svn.example.com/try/
• Subversion repository local: http://svn.mycomputer/try/
• SVK depot: /try/

svk depot try ~/.svk/try
svk mirror /try/remote http://svn.example.com/try/
svk sync /try/remote
svk mirror /try/localsvn http://svn.mycomputer/try/
svk sync /try/localsvn
svk smerge /try/remote /try/localsvn

Checkout & working copy:

svn co http://svn.mycomputer/try/trunk/

Commit:

svn ci

Push: (merge to remote)

svk sync /try/localsvn
svk sync /try/remote
svk smerge /try/localsvn /try/remote

Pull: (merge from remote to local)

svk sync /try/localsvn
svk sync /try/remote
svk smerge /try/remote /try/localsvn

Tip: Moving local Subversion repository history to remote Subversion server

Assumptions:

• Subversion repository remote (still empty): http://svn.example.com/try/
• Subversion repository local (has history): http://svn.mycomputer/try/
• SVK depot: /try/

In short:

svk depot try ~/.svk/try
svk mirror /try/remote http://svn.example.com/try/
svk sync /try/remote
svk mirror /try/localsvn http://svn.mycomputer/try/
svk sync /try/localsvn
svk smerge --incremental --log --baseless /try/localsvn /try/remote

Versi Indonesia

UPDATE: Versi ini sudah out-of-date. Versi paling up-to-date dengan tips-tips tambahan dan edisi revisi ada di wiki Ruby Indonesia: SVK.

SVK adalah sistem version control terdistribusi.

Cara 1: Pake Subversion repository, SVK working copy

Asumsi:

• Subversion repository remote: http://svn.example.com/coba/
• SVK depot: /coba/

svk depot coba ~/.svk/coba
svk mirror /coba/remote http://svn.example.com/coba/
svk sync /coba/remote
svk cp /coba/remote /coba/local

Checkout & working copy:

svk co /coba/local/trunk

Commit:

svk ci

Push: (merge ke remote)

svk push

Pull: (merge dari remote ke local)

svk pull

Cara 2: Pake Subversion repository remote, Subversion repository local, dan SVK untuk merge

Kelebihan dari cara ini adalah Anda bisa menggunakan tools Subversion seperti biasanya (TortoiseSVN, maupun native utility dari Aptana IDE, NetBeans, dsb.)

Asumsi:

• Subversion repository remote: http://svn.example.com/coba/
• Subversion repository local: http://svn.mycomputer/coba/
• SVK depot: /coba/

svk depot coba ~/.svk/coba
svk mirror /coba/remote http://svn.example.com/coba/
svk sync /coba/remote
svk mirror /coba/localsvn http://svn.mycomputer/coba/
svk sync /coba/localsvn
svk smerge /coba/remote /coba/localsvn

Checkout & working copy:

svn co http://svn.mycomputer/coba/trunk/

Commit:

svn ci

Push: (merge ke remote)

svk sync /coba/localsvn

svk sync /coba/remote

svk smerge /coba/localsvn /coba/remote

Pull: (merge dari remote ke local)

svk sync /coba/localsvn
svk sync /coba/remote
svk smerge /coba/remote /coba/localsvn

Tip: Mindahin history Subversion local ke remote

Ini pertanyaan dari Marcel.

Asumsi:

• Subversion repository remote (masih kosong): http://svn.example.com/coba/
• Subversion repository local (sudah berisi): http://svn.mycomputer/coba/
• SVK depot: /coba/

So singkatnya:

svk depot coba ~/.svk/coba
svk mirror /coba/remote http://svn.example.com/coba/
svk sync /coba/remote
svk mirror /coba/localsvn http://svn.mycomputer/coba/
svk sync /coba/localsvn
svk smerge --incremental --log --baseless /coba/localsvn /coba/remote

Credits

Thanks buat Marcel ([1]) yang sudah menyumbang pertanyaan yang akhirnya membuat saya menulis artikel ini. Trims. –Ceefour 11:23, 22 Agustus 2007 (CDT)

No related posts.

Related posts brought to you by Yet Another Related Posts Plugin.

Who said Capistrano is for Ruby on Rails only?

That’s probably the major tagline of the whole Capistrano 2.0 saga. You can use it to deploy PHP, Django, or not doing any deployment at all. Let me demonstrate, this time using Joomla:

Capistrano adalah library/tool yang digunakan untuk meng-online-kan aplikasi Ruby on Rails, tapi bisa juga digunakan untuk aplikasi PHP, misalnya Joomla:

ceefour@ojalanow:~/project/layout_mania/trunk$ cap deploy
  * executing `deploy'
  * executing `deploy:update'
 ** transaction: start
  * executing `deploy:update_code'
  * executing "svn checkout -q --username ceefour --no-auth-cache -r11 http://tools.assembla.com/svn/layout_mania/trunk /home/rainbow/apps/layout_mania/releases/20070814160555 && (echo 11 > /home/rainbow/apps/layout_mania/releases/20070814160555/REVISION)"
    servers: ["rainbowpurple.com"]
    [rainbowpurple.com] executing command
    command finished
  * executing `deploy:finalize_update'
  * executing "chmod -R g+w /home/rainbow/apps/layout_mania/releases/20070814160555"
    servers: ["rainbowpurple.com"]
    [rainbowpurple.com] executing command
    command finished
    triggering after callbacks for `deploy:finalize_update'
  * executing `deploy:symlink_secret'
  * executing "ln -s /home/rainbow/apps/layout_mania/secret /home/rainbow/apps/layout_mania/releases/20070814160555/secret"
    servers: ["rainbowpurple.com"]
    [rainbowpurple.com] executing command
    command finished
  * executing `deploy:use_live_configuration'
  * executing "cp -f /home/rainbow/apps/layout_mania/releases/20070814160555/joomla/configuration.php.live /home/rainbow/apps/layout_mania/releases/20070814160555/joomla/configuration.php"
    servers: ["rainbowpurple.com"]
    [rainbowpurple.com] executing command
    command finished
  * executing `deploy:symlink_cache'
  * executing "rm -rf /home/rainbow/apps/layout_mania/releases/20070814160555/joomla/cache && ln -s /home/rainbow/apps/layout_mania/shared/cache /home/rainbow/apps/layout_mania/releases/20070814160555/joomla/cache"
    servers: ["rainbowpurple.com"]
    [rainbowpurple.com] executing command
    command finished
  * executing `deploy:symlink'
  * executing "rm -f /home/rainbow/apps/layout_mania/current && ln -s /home/rainbow/apps/layout_mania/releases/20070814160555 /home/rainbow/apps/layout_mania/current"
    servers: ["rainbowpurple.com"]
    [rainbowpurple.com] executing command
    command finished
 ** transaction: commit
  * executing `deploy:restart'

The result? layout-mania.humblia.com. Below is the source code of deploy/config.rb used to deploy this Joomla app.

Hasilnya? layout-mania.humblia.com. Di bawah ini adalah source code dari file konfigurasi Capistrano deploy/config.rb yang digunakan untuk aplikasi ini.

set :application, "layout_mania"
set :repository,  "http://tools.assembla.com/svn/layout_mania/trunk"

# If you aren't deploying to /u/apps/#{application} on the target
# servers (which is the default), you can specify the actual location
# via the :deploy_to variable:
set :deploy_to, "/home/rainbow/apps/#{application}"
set :user, "rainbow"
set :scm_username, 'ceefour'
set :use_sudo, false
set :cache_path, "#{shared_path}/cache"
set :media_path, "#{shared_path}/media"

# If you aren't using Subversion to manage your source code, specify
# your SCM below:
# set :scm, :subversion

role :app, "rainbowpurple.com"
role :web, "rainbowpurple.com"
role :db,  "rainbowpurple.com", :primary => true

after 'deploy:finalize_update', 'deploy:symlink_secret'
after 'deploy:finalize_update', 'deploy:use_live_configuration'
after 'deploy:finalize_update', 'deploy:symlink_cache'

namespace :deploy do

  # Overwritten to provide flexibility for people who aren't using Rails.
  task :setup, :except => { :no_release => true } do
    dirs = [deploy_to, releases_path, shared_path, cache_path, media_path]
    dirs += %w(system).map { |d| File.join(shared_path, d) }
    run "umask 02 && mkdir -p #{dirs.join(' ')}"
  end

  # Also overwritten to remove Rails-specific code.
  task :finalize_update, :except => { :no_release => true } do
    run "chmod -R g+w #{release_path}" if fetch(:group_writable, true)
  end

  # Each of the following tasks are Rails specific. They're removed.
  task :migrate do
  end

  task :migrations do
  end

  task :cold do
  end

  task :start do
  end

  task :stop do
  end

  # Do nothing (To restart apache, run 'cap deploy:apache:restart')
  task :restart do
  end

  task :use_live_configuration, :roles => :app do
    run "cp -f #{release_path}/joomla/configuration.php.live #{release_path}/joomla/configuration.php"
  end

  task :symlink_cache, :roles => :app do
    run "rm -rf #{release_path}/joomla/cache && ln -s #{cache_path} #{release_path}/joomla/cache"
  end
  task :symlink_secret, :roles => :app do
    run "ln -s #{deploy_to}/secret #{release_path}/secret"
  end

end

namespace :db do

  desc "Overwrite the remote database with local database."
  task :push_force, :roles => :db do
    system "mysqldump --opt rainbow_layoutmania | bzip2 > /tmp/rainbow_layoutmania.sql.bz2"
    system "rsync -vPa /tmp/rainbow_layoutmania.sql.bz2 rainbowpurple.com:tmp/"
    run "bunzip2 -dc /home/rainbow/tmp/rainbow_layoutmania.sql.bz2 | mysql -u rainbow_layoutma -p`cat #{deploy_to}/secret/db_password` rainbow_layoutmania"
    run "rm -f /home/rainbow/tmp/rainbow_layoutmania.sql.bz2"
    system "rm -f /tmp/rainbow_layoutmania.sql.bz2"
  end

  desc "Optimize remote database."
  task  ptimize, :roles => :db do
    run "mysqlcheck --analyze --repair --optimize --user=rainbow_layoutma --password=`cat #{deploy_to}/secret/db_password` rainbow_layoutmania"
  end

end

Interested? Unfortunately this isn’t a tutorial. Look more on the resources below:

Tertarik? Sayang sekali ini bukan tutorial, coba cari informasi lebih lanjut di:

• Capistrano 2.0 official site
• Capistrano Wiki
• Deploy any project using Capistrano 2
• Automate the deployment of any PHP project using Capistrano 2.0
• Jamis Buck’s blog (creator, lead developer, and chief inventor of Capistrano )
• Capistrano and the Rails Application Lifecycle book from O’Reilly

Note: Sorry for dual-language posting, any better suggestion?

No related posts.

Related posts brought to you by Yet Another Related Posts Plugin.