Serving static pages with Rails Metal is actually very simple. Here are the assumptions we’re making.
- Each static page’s content is made up of valid HTML.
- Each static page has a path and content stored in a StaticPage object as defined by the StaticPage model.
- If the path browsed matches the path in a StaticPage object, the content is what is to be delivered.
Here’s the code: Read More
HTML, Rails, Rails Metal, response, Ruby on Rails, tutorial
A few weeks ago, I wrote 9 Ways to Use Rails Metal. The third way to use Rails Metal was implementing a simple API.
Before I provide the code and an explanation, I’d like to cover a few things. First, this API only requires an API key. If you want an authentication token or some other identifier, look at Rails Metal Example #1: Authentication for some ideas of how to manage authentication for your API. Second, I didn’t filter any contents on the User model, so the password is passed back by the API. A simple delete call for the keys you want to omit from the hash returned by the find_by_sql call should clear up any data you don’t want to pass back.
Here’s the code:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
| # Allow the metal piece to run in isolation
require(File.dirname(__FILE__) + "/../../config/environment") unless defined?(Rails)
class ApiHandler
def self.call(env)
req = Rack::Request.new(env)
@params = req.params
if (env["PATH_INFO"] =~ (/^\/api\/(xml|json)\/user\//)) && ApiKey.find_by_key(@params["key"]) && env["REQUEST_METHOD"] == "POST"
format = env["PATH_INFO"].split("/")[2]
return [200, {"Content-Type" => "application/xml"}, [User.find_by_sql(["SELECT * FROM users WHERE id = ?", @params["id"]]).to_xml]] if format == "xml"
[200, {"Content-Type" => "application/json"}, [User.find_by_sql(["SELECT * FROM users WHERE id = ?", @params["id"]]).to_json]] if format == "json"
else
[404, {"Content-Type" => "text/html"}, ["Not Found"]]
end
end
end |
The code here is pretty simple. You check the path to make sure it matches the api path for XML or JSON, then find the record, convert it, and send it off to the user.
A few things to note are that the Rails methods to_json and to_xml are available in Rails Metal. I also had to explicitly return on the xml format because it isn’t the last execution and therefore isn’t returned.
API, JSON, MySQL, Rails Metal, tutorial, XML
A week and a half ago, I posted 9 Ways to Use Rails Metal. The fourth way I listed was “Redirecting Affiliate Links.” The basic idea is that you can set up http://mydomain.com/hosting to go to the link you were given by the hosting company you have an affiliate account with.
The first thing I did was set up a model to manage affiliate redirects.
script/generate model affiliate_redirect path:string location:string
Then I ran my migrations, to set up the database.
Then I set up a Rails Metal instance called affiliate_redirects.
script/generate metal affiliate_redirects
From there, programming Rails Metal was pretty simple. You just have to find an AffiliateRedirect with the path visited and redirect to the AffiliateRedirect’s location. Here’s the code:
1
2
3
4
5
6
7
8
9
10
11
12
| require(File.dirname(__FILE__) + "/../../config/environment") unless defined?(Rails)
class AffiliateRedirects
def self.call(env)
redirect = AffiliateRedirect.connection.select_all("SELECT * FROM affiliate_redirects WHERE path = '#{env["PATH_INFO"]}'").first
if redirect && (location = redirect["location"])
[302, {"Content-Type" => "text/html", "Location" => location}, ["You are being redirected."]]
else
[404, {"Content-Type" => "text/html"}, ["Not Found"]]
end
end
end |
This is the quick solution to the Rails action with nothing but a redirect_to.
middleware, Rails Metal, redirect, Ruby on Rails, tutorial
I’ve had a few requests on how to access the session from Rack and Rails Metal. In the Rack environment that is passed to the call method, the session is stored at the ‘rack.session’ index. You can use this to both read from and write to the session. Here are some examples:
1
2
| session = env['rack.session']
User.find_by_id(session["user_id"]) |
1
2
| session = env['rack.session']
session["user_id"] = 1 |
rack, Rails, Rails Metal, sessions
Last week, I wrote a post listing 9 ways to use rails metal. This is an explanation of the first way to use Rails Metal: Check Authentication.
We’re setting up this Rails Metal to handle two scenarios: requiring authentication, and logging the user in. First, it verifies that requests to any path beginning with /admin have a user logged in by checking that a valid user id is stored in the session. Second, accepts an HTTP POST to /authenticate with a username, password, and target path for redirect upon
Before we get too deep into things, let me share the code. You can check out a working version of the application on GitHub.
Here’s the Metal.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
| require(File.dirname(__FILE__) + "/../../config/environment") unless defined?(Rails)
class Authentication
def self.call(env)
session = env["rack.session"]
request = Rack::Request.new(env)
params = req.params
if env["PATH_INFO"] =~ /^\/admin.*/ && (session["user_id"].nil? || (session["user_id"] && User.connection.select_all("SELECT * FROM users WHERE id = #{session["user_id"]}").empty?))
[302, {"Content-Type" => "text/html", "Location" => "/login?target_path=#{env["REQUEST_URI"]}"}, ["You must be logged in to view this page. You are being redirected."]]
elsif env["REQUEST_METHOD"] == "POST" && env["PATH_INFO"] =~ /^\/authenticate/
users = User.connection.select_all("SELECT * FROM users WHERE username='#{params["user"]["username"]}' AND password='#{params["user"]["password"]}'")
unless users.empty?
session["user_id"] = users.first["id"]
[302, {"Content-Type" => "text/html", "Location" => "#{params["target_path"] || "/"}"}, ["You have been logged in. You are being redirected."]]
else
[302, {"Content-Type" => "text/html", "Location" => "/login"}, ["Authentication failed. You are being redirected."]]
end
else
[404, {"Content-Type" => "text/html"}, ["Not Found"]]
end
end
end |
Bases for Understanding the Code
There are a few methods and structures here that are important to note in how this all works.
First, the self.call(env) is the entry point for the Rails Metal application. env refers to the Rack environment.
Next, Rack::Request is a class that provides a convenient interface to the Rack environment. In this case, we’re using it to extract the GET and POST parameters from the request. You can see the full Rack::Request API here.
env['rack.session'] returns the session as a hash. In this case, keys are accessed as strings, not symbols. So, in our case, session[:user_id] won’t work, but session["user_id"] will work.
Finally, we do direct SQL calls through the ActiveRecord object rather than using the find method because it’s faster and we only need a few fields like the id of the user that’s found.
Overview of the Code
Checking Authentication
Our authentication code creates a session variable called user_id and places the current user’s id into it. So, to make sure someone is logged in, we need to make sure that a valid user id is in the session.
To do this we check if the path begins with /admin. env["PATH_INFO"] contains the path without any GET parameters. So, we do a regular expression match and them move on to checking if there’s a valid user id in the session.
There are two scenarios that we need to check. There is no user id stored in the session and the user id stored is not the id of a valid user.
If both conditions are met, we redirect the user to /login and pass along the path the user was trying to access as a GET parameter called “target_path.”
Logging the user in
If a valid username and password are passed to the path /authenticate, we need to store the user’s id in the session and redirect them to where they were trying to go. To check the username and password, we query the database. If no matches are found in the database, then we send them to the login page.
Overall the code is pretty simple. Feel free to use it in any of your applications. I’ll post the benchmarks when I get a chance, but several people were looking for this content, so I’m putting it out now.
activerecord, authentication, middleware, MySQL, Rails, Rails Metal, Ruby on Rails, security
