Back in 2009, our Leandro (a.k.a TatooKa) wrote an awesome post on how to use curl to do POSTs and other HTTP magic. Back then curl was the way to go when you wanted to do command line HTTP GET/POST/PUT. Nowadays there’s a simpler and more modern variation: httpie.

To install on Ubuntu just do:

$ sudo apt-get install httpie

Once installed, you can do a simple HTTP POST with form variables like so:

$ http --form POST api.myservice.com/auth/login username=guest password=secretpassword

as a response you would get something like this (a JSON response in this case):

As you can see the response is much cleaner: there’s color coding showing you the response headers, the body is detected to be a JSON object and its nicely formatted. To see many other cool examples go to its page on Github: https://github.com/jkbr/httpie

I was playing around and wanted to have a command line interface script to see the latest titles from Drupal Planet. I wipped this Python script to read and display the RSS feed. You need to install feedparser (in Ubuntu: $ sudo aptitude install python-feedparser). Here’s the code:

To run it:

$ python planet.py

You can save it in ~/bin and create an alias with: $ alias planet='python ~/bin/planet.py' and execute it simply from the CLI with: $ planet

Here’s how it looks:

If you use drush and code modules/templates in Drupal you know the symptom: add a new template file, add a hook to your module, pretty much change a few things in your code and you issue a drush cc all ‘just in case’. Drupal has an extensive cache system which is your friend but unfortunately when coding you often have to clear it so that the new changes can be detected. This constant ‘clear all caches’ can really slow you down. On large sites a drush cc all can take as long as 15-20 seconds to complete. If you are not sure your overriding the correct template or hook then it can become a little annoying  to waste so much time.

As you probably know, Drupal has more than one cache. Wouldn’t it be great if you could just clear the cache which you know needs to be cleared and avoid clearing the others which don’t have an impact? It turns out you can! The only problem is knowing what modifications go into what cache. You could spend some time going through core but it’s probably easier to do it by trial and error. Because of this issue I decided to experiment a little in my latest projects and waste a little more time to compile a list of drush cc commands and when you should issue them. Here’s what I have so far:

$ drush cc css-js

• If you have turned on CSS and JS aggregation you can use this to regenerate the aggregated CSS and JS.

That’s what I have so far. It’s been a real time saver for me. If you have other drush cc xxxx commands to share leave a note and I’ll add them to the post. Maybe later I’ll add a page to the drush page at drupal.org

Credits

• Thanks to Hjalmar from Nodeone for the drush cc css-js tip!

Using ssh to shut down lights

As you all might know ssh is a very popular protocol used to connect to remote shells. I mostly use OpenSSH as a client (I think most of you to). SSH has a lot of cool options but in this post i’m going to write about how to use it to create a secure tunnel.

What is a tunnel?

A tunnel specifies a given port on the local (client) host that is to be forwarded to the given host and port on the remote side. How it works? This works by allocating a socket to listen to a port on the local side, optionally bound to the specified bind_address.  Whenever a connection is made to this port, the connection is forwarded over the secure channel, and a connection is made to the port from the remote machine.

Making the tunnel

Before type the command line to create the ssh tunnel I’m assuming the following topology

If I would like to connect to 192.168.0.2 db server and the database is a postgresql, then the default port is 5432 and the tunnel command line is:

$ ssh -L 5432:192.168.0.2:5432 <user>@<web server>
     _____^______     ______^______
    / local port \   / remote port \

If you are running a postgresql in your own machine you can chose another port to listen in your loop back. I always have a pgsql running in my laptop because I use it in most of my developments and I use port 5435.

$ ssh -L 5435:192.168.0.2:5432 <user>@<web server>

============================================================
 from other terminal
============================================================

$ psql -h localhost -p 5435 -U db_user -d db_name
Welcome to psql 7.3.4, the PostgreSQL interactive terminal.

Type:  \copyright for distribution terms
 \h for help with SQL commands
 \? for help on internal slash commands
 \g or terminate with semicolon to execute query
 \q to quit

db_bame=#

You can make a tunnel to many ports at the same time.

$ ssh -L 5435:192.168.0.2:5432 -L 5436:192.168.0.3:5432 <user>@<web server>

or

$ ssh -L 5435:192.168.0.2:5432 -L 2222:192.168.0.2:22 <user>@<web server>

then try to connect to ssh remote service using the tunnel

$ ssh -p 2222 user@localhost

SSH tunnel is something very useful in my life. I hope this post helps you to make it useful for you to.

and a half …

Many router or firewall (statefuls for example)  try to clean up dead connections, that means that they are looking  if no data was trasmited in the last N secs, and then asumes that connection is no longer in use. For example I go to get some cofe and when I come back to my desk I see this in my monitor:

lucas@megara:~$ Read from remote host megara.easytech.com.ar:
Connection reset by peer
Connection to megara.easytech.com.ar closed.  

%$#&*@#$^!@#&*$#%^!#@ <- my thoughts

I hate when this happens and more if I have all my tunnels created. I way to fix this is enabling the keep-alive option. What this does, essentially is every N seconds, the client sends a small keep-alive packet to the server to make it look like the ssh connection is being actively used.

To enable  all your ssh connections to send a keep-alive packet you just have to add the following lines to your ~/.ssh/config file:

KeepAlive yes
ServerAliveInterval 60

In most cases this option is very useful but if the connection is down and the keep-alive packet is sent the SSH will disconnect you, so you have to be careful in witch scenarios use this option.

There are many other options to play with but I would like to recommending you take a look at ssh multiplexing and how to use ssh as a proxy ( see the 2600 summer 2011 for a very good article about this).

@lucasmingarro

Hace aproximadamente un año atras decidimos que en algún momento ibamos a arrancar con un nuevo emprendimiento, al cual bautizamos a modo de juego, lanubecita.

El tiempo fue pasando y lanubecita se fue haciendo cada vez más real.

La diferencia puntual entre lo que hacemos en easytech vs lanubecita es que en el primero hacemos desarrollos a medida para nuestros clientes y en lanubecita desarrollamos aplicaciones web que  vamos a comercializar como servicios (SaaS).

Con la intención de compartir nuestros pensamientos y lo que vayamos experimentando mientras transitamos por este nuevo startup, es que anoche creé un blog usando posterus, el cual me convenció por los lindos themes que tiene y  cuyo url es http://blog.lanubecita.com

nice to meet you.

TermKit is graphical replacement for the old Unix terminal developed by Steven Wittens. It is based on the WebKit HTML rendering engine used in Safari and Chrome. The only ‘problem’ with TermKit is that you need a Mac with OS X to use it. Since we are Linux users we wanted to at least give it a try and found that you can test it using Chrome. In this post I cleaned up the instructions for testing TermKit on a machine with Ubuntu.

The idea is detailed in this fork at Github: https://github.com/Floby/TermKit/commit/2e18c8d622443a671a626a7815006ce187743ea2.

Make sure you have git, libssl-dev and Google Chrome installed. To install git and libssl-dev do: sudo aptitude install git libssl-dev and sudo aptitude install google-chrome-beta will install Google Chrome.

With those two installed (most developers already have them) then follow these commands to build Node.js, npm and finally run TermKit. To compile this you may need to include other dependencies but in my machine they were already installed.

The following steps will create a directory called TermKitProj in your home directory and install everything you need inside it.

$ cd ~
$ mkdir TermKitProj
$ cd TermKitProj
$ git clone https://github.com/joyent/node.git
$ cd node
$ ./configure
$ make

wait a while until Node compiles …

$ sudo make install
$ cd ..
$ git clone http://github.com/isaacs/npm.git
$ cd npm
$ sudo make install

wait a little more …

$ cd ..
$ git clone https://github.com/Floby/TermKit.git --recursive
$ cd TermKit/
$ npm install
$ node Node/nodekit.js

The last command starts the backend in your terminal. You should see something like this:

miquel@inspire:~/Develop/TermKitProj/TermKit$ node Node/nodekit.js
21 May 13:10:27 - Your node instance does not have root privileges. This means that the flash XML policy file will be served inline instead of on port 843. This will slow down initial connections slightly.
21 May 13:10:27 - socket.io ready - accepting connections
server listening at http://localhost:2222
21 May 13:10:41 - Initializing client with transport "websocket"
21 May 13:10:41 - Client 8840208831243217 connected
worker:  config @{}@

Once this is running fireup Chrome and open this URL: http://localhost:2222 and you should see something like this:

Some time ago we begin to need something to manage our clients requirements because it was  already a very high entropy. After some research (that means google) we were unable to find a simple app that fit our needs. At this point  Cesar decided to implement Drupal + Support Ticket System module.

As always this module had not all we needed and as always we finished  changing the module’s code, creating new views and a lot of Drupal theming to get a better functionality and a better UI to the way we work. Since then  we have been using it (2 years actually) we very good results.

Check out how guick looks like right now.

After a lot of iterations and improvements over the this time and seeing that our clients (we also) are very happy with this app we started thinking about selling it. For this purpose we called this application guick and we build a pre-launch page in the following url http://guickapp.com to collect some email addresses. btw I thought it would take 4 or 5 hours but as always I was wrong (3 days actually).

 Some feedback will be welcome and not be shy and type your email address if you are interested

@lucasmingarro

It often happens that you are trying to debug a PHP script running from command line or a part of your code and the script mysteriously dies. Depending on your server configuration (or command line) errors may be being silently being hidden. In those cases I recommend you add the following lines to your code to guarantee that all errors, notices, etc will be printed.

This post is really for reference since most PHP developers already know this …

We do a lot of development in PHP here at Easytech. Many times you need to test a bit of PHP code. If you played around with python you surely used the python shell. Fortunately the people at Facebook have created a similar shell for PHP (ironically written in python!). You can find it here: http://www.phpsh.org/. From there you can access the GIT repository or download a tgz or zip file.

Currently I couldn’t find a DEB package for Ubuntu. If you want to install it just follow the following steps (you need python installed)

thats it! To test some PHP weirdness…

Very often when I review other peoples PHP code I come across an old problem: generating a list of comma separated values from a list of things. This happens often when you want to, say, write an SQL query with a WHERE field IN (a,b,c,…,x) and you have an array with a, b, etc.

Another example is when you want to create an include path by concatenating a list of directories with the PATH_SEPARATOR. Yet another example is when you want to build a path concatenating them with the DIRECTORY_SEPARATOR.

The usual code to accomplish looks something like this:

There is really nothing wrong with this code snippet. The last line is kind of ‘ugly’: while you are looping over the array and are concatenating a string with ‘,’ you don’t know which is the last element in the list. This means that when the loop is done you have an extra ‘,’ character. The solution: use substring to remove the final ‘,’. Another alternative is:

This way we use a regular expression to replace the last ‘,’ with a blank. A bit nicer than the substr() example. Both ways are ok but PHP has a really nice function called implode(). What implode() does is it takes a list or array and joins it with whatever character/s you want. So, the code we just wrote can be replaced with the much cleaner:

With implode() you don’t need to do weird stuff to remove the last ‘,’ or whatever char/chars you used to concatenate the string. Another advantage is that the code is much faster since implode() is implemented in C code.

The implode() function has another useful and related function: explode(). This function takes a delim delimiter and a subject string and returns an array of strings which is obtained by splitting the subject using the delimiter. I’m quite sure you’ve used explode(). It’s used when you want to, for example take a comma separated list and parse it to obtain the fields. Of course if you want to parse a CSV file you should use another PHP function: fgetcsv(); but that is for another post…

So, the moral of this post should be: before embarking on doing weird things first take a look at the PHP library of functions. Chances are that someone has come across the same problem and have solved it and included it as a PHP function or library. The advantage is that these functions not only execute faster since they are straight C code but also have been tested by thousands of programmers and, in most cases, are known to work. This is often the case when you have to do operations on dates. For example: calculate what day of the month is next Friday, etc. This functions are quite tricky to write because there are a lot of border cases: leap years, change of month / year, etc. If you write
them your are quite likely to forget about some border case. You should always use library functions and particularly PHP library functions which have been extensively tested and used for years.

If you are developing a module for Drupal you might need to use tabs to simplify a bit a screen which has too much functionality. Typically a settings page that might need too many options to comfortably fit on a single screen. Since I had to search and experiment a bit to find out how to do it I decided to write a short post with my findings. In this article I assume you have a basic understanding on writing Drupal modules.

Basically you define what content goes in what tab in your modules hook_menu() function defining menu items which are called MENU_LOCAL_TASK. Suppose I want a page which has two tabs: Company and Mail as seen on the screen shot. This is the corresponding hook_menu() code:

Here are the main highlights of how this works:

• The first item should be a standard menu item and its route should be shared with the other tabs. In this case, the route is ‘settings’.
• Each additional tab should be of type MENU_LOCAL_TASK.
• You need at least two tabs. If you only have one child route then you will not see a tab.
• If you add more than one MENU_LOCAL_TASK, you must single out one as required by setting its type to MENU_DEFAULT_LOCAL_TASK. The default local task doesn’t need a ‘page callback’ since it is handled by the root item.
• Additional tabs should be of type MENU_LOCAL_TASK and should have a page callback function assigned to them.
• The ‘title’ of the standard item appears a the top of the tab bar. The title of the MENU_LOCAL_TASK and MENU_DEFAULT_LOCAL_TASK are used as the titles on the individual tabs.
• You can change the order of the tabs by adding a ‘weight’ item to each menu
  item.
• You need to specify an ‘access callback’ item and have permissions to view the corresponding tab.

Finally, remember that each time you change an item in hook_menu() you need to flush your cache so that the items are re-read. This can be achived by going to admin->settings->performance and hitting clear cache or by using drush and doing ‘drush cache clear’.

Drupal has a sophisticated module system that allows developers to extend the CMSs functionality very easily. Each module “hooks” into Drupal by implementing hook functions. On way to use this feature is to hook different URLs to module functions. Essentially the developer in his module declares an array of url paths and what function should be called when that path is requested. This small post will show you how you can determine which module handles a specific URL. This can be quite useful for debugging and/or browsing other peoples source code to learn how to do something.

Every module in Drupal that hooks to a URL path needs to implement the hook_menu function. This hook basically tells Drupal what paths will be handled by this module. This information is read when the module is enabled and stored in a database table. In Drupal 6 this information is cached so if you modify the array returned by the hook_menu function you need to clear the cache. To determine what module is handling what path you simply need to query the menu_router table. A simple query to do this is:

This table has more information that might be useful: access_callback and access_arguments store information related to what access function is called to determine who has access to that path, page_arguments stores information related to what arguments to pass to the callback function. This is specially relevant when the page_callback function is drupal_get_form in which case Drupal will render a form and this field stores the name of the form to render.

An example usage might be:

$ drush sql cli
Welcome to the MySQL monitor.  Commands end with ; or \g.
Your MySQL connection id is 1859
Server version: 5.0.77 Source distribution

Type 'help;' or '\h' for help. Type '\c' to clear the buffer.

mysql> SELECT path, file, page_callback FROM menu_router ORDER BY path;

+-----------------------------------+---------------------------------+------------------------------+
| path                              | file                            | page_callback                |
+-----------------------------------+---------------------------------+------------------------------+
| admin                             | modules/system/system.admin.inc | system_main_admin_page       |
| admin/build                       | modules/system/system.admin.inc | system_admin_menu_block_page |
| admin/build/block                 | modules/block/block.admin.inc   | block_admin_display          |
| admin/build/block/add             | modules/block/block.admin.inc   | drupal_get_form              |
| admin/build/block/configure       | modules/block/block.admin.inc   | drupal_get_form              |
| admin/build/block/delete          | modules/block/block.admin.inc   | drupal_get_form              |
| admin/build/block/list            | modules/block/block.admin.inc   | block_admin_display          |
| admin/build/block/list/bluemarine | modules/block/block.admin.inc   | block_admin_display          |
| admin/build/block/list/chameleon  | modules/block/block.admin.inc   | block_admin_display          |
| admin/build/block/list/donline    | modules/block/block.admin.inc   | block_admin_display          |
  .....

mysql>

Today I needed to generate source code documentation for a webservice APIs we are in coding. One of the guys in the office suggested I take a look at Zend_Reflection. It turns out its quite simple to write PHP code to parse source files and extract the documentation from them. I took a little time to write this sample program.

This program is quite simple: it has a single class called TestClass with one method: addIntegers(). Below this class I wrote a little code which parses the file and then outputs the information. You can use this and a templating system to generate doc. I used it to write the documentation so that we can easily add it to our Wiki.

The script I wrote parses the documentation style used in Zend Framework. Here’s a sample class:

Read the rest of the post to see how to easily parse this code…

Below is the complete sample code. Fire up your text editor, copy-and-paste this code into it, save it as test_zend_reflection.php and run it. Hope this helps!

If you run our PHP code you get:

Zend Framework recently introduced the concept of modules so that your applications become more manegable. The application on startup will load the resources defined in the main application.ini file. To configure each module there is a resource called modules that calls the bootstraping code for each module on every request. If you want to load resources on a per module basis you need to write a bootstrap for each module. This can also generate clashes if two modules try to load the same resource. Additionally this process can have a negative impact on your applications performance.

In this blog I propose a different strategy: I created a controller action plugin that will load resources dynamically using the main bootstraping code. The idea is that after the routes are parsed and before the action is executed this code will load the module’s config file and call the bootstrap again so that it will load the resources defined in this config.

This method has several advantages: only the resources for the module that is being called are loaded. Becuase only one config file is read there is no possiblity of clashes.

Here’s the code:

When developing multi-organization web applications it is of utmost importance that data from one organization is not visible to the other. There are several software aproaches for this. Usually this can be solved by having an organization ID and whenever a query is made a ‘where’ clause is added to filter by organization. Although this approach works fine it is up to developers to always filter by org_id but its certainly error prone.

To solve this problem there are other approaches. One is that each organization gets a copy of the database and a single database user to log to this database. When the user logs in the application uses the URL to determine the organization (say: http://organization.domain.com/login). With the organization name extracted from the URL, the aplication determines which database instance, database user and password to use for the application to use. This obviously solves the problem since, by definition, there is no way data from the two organizations can mix: they live in different databases alltogether.

The problem with the above approach is that, if you have a large number of organizations that means you have a large number of databases. In the case of thousands of organizations (don’t think corporations, think small business owners which use your webapp daily) then there might be performance issues in the database since regular databases are not designed to have thousands of small databases. At least the ones I know of.

Chatting about this problem with the nice folks over at the #postgres IRC channel on the FreeNode servers they pointed me to two different approaches. One was to use PL/pgSQL code to isolate all access to the data. You have PL/pgSQL code which takes a user as a parameter and uses it to filter or insert the data into tables which have an org_id column.

A second approach which seemed more interesting to me was to create a schema for each organization and encode the organization_id in the schema name. Then you can create an updatable view which uses the schema name to filter the data by organiation_id.

The last approach appealed to me more because I wanted the database to take care of the filtering. The problem with it is that you have to create a schema for each new user. Another setback the guys at #postgres pointed out was that connection spooling is not possible (I don’t know enough postgres to understand why).

In this article I will point out a slighly different approach our team at Easytech came up with inspired by this last method. The idea is that when the applications logs into the database it sets the organization ID as a kind of ‘session parameter’ . All data is accesible through updatable views and this views filter the data using de org_id. When data is updated in the table the org_id is pulled from the ‘session’ and inserted in the original table so that it can be marked as beloging to that organization.

The trick here is to create a run-time paramater. To do this you need to modify your postgres.conf file and add a parameter. For example:

After re-starting the server you can now connect to the server with psql and set the value of org.id with:

Lets see how we can use this to create views which display different data to different application users:

As you can see with this approach each application user can see different data from the same table. When a user logs into the application we pull the organization from the URL and use it to setup the session parameter. Once the session paramater is set, all views of sensitive data filter by org_id. Of course if you select from the original tables then you will see all data. It is important that the development team only use this filtered views to access the data.

We still have to investigate how this technique might work in a real application. Another issue to study is how to perform joins with several views and how it performs. We will report how this technique turns out in another posting.

Sometimes I need to use data from a csv (comma separated values) in an oracle procedure. The best way to do that is inserting the data into a db table using sqlloader and then reading it from the PL/SQL.

In this post I will show you how to use sql loader to load a csv file exported from excel into an oracle table.

Suppose that you got a XLS spreadsheet with contact data: first name, last name, security number, phone number.

First, create a table where the file will be loaded:

In my xls (people.xls) I have the following info:

Save the data as a comma delimited file.

File -> Save As
Change File name to people_csv
Select ‘Text CSV ’ in the File type drop down box.

If you open the people_csv.csv file in a text editor (vi in my case), you will see it in a comma separated format. Two commas will denote fields without a value, these will be loaded as nulls into the Oracle table.

CSV file:

Create the following sql loader control file (people_ctrl.txt)

at last  run the sql loader to put the info into the db table.

Now I can use the data from sql with a simple query:

curl es un programa que nos permite transferir datos (o archivos) desde o hasta un servidor, a través de distintos protocolos (entre ellos HTTP, FTP, SCP, etc).

hackers usando curl para testear un SQL injection

Lo interesante (y lo más usado entre los code-monkeys de Easytech) es su uso para emular POSTs a ciertas URLs, sin tener que pasar por la página en el browser.

si no lo tienen, pueden bajarlo del link anterior, aunque tiene fama de estar en todos los repos de las distros conocidas.

En mi caso particular, curl me fue muy útil para hacer un POST a una de las webapps que desarrollamos, y poder chequear el XML que devolvía, sin complicaciones ni pasar por un web-browser.

un PM de Easytech le enseña a un junior a probar sus Forms con curl.

empecemos por lo más básico, emular un formulario. esto lo hacemos con curl -F, o curl -d (dependiendo del content-type que querramos usar). La sintáxis sería algo como:

Otro uso interesante es el de hacer upload de files, emulando un de un form html. La sintáxis:

o…

… si queremos un nombre específico para el file.

Nótese que la arroba delante del path del file es obligatoria.

Claro que, lo que yo quería, era ver qué me devolvía la aplicación (en este caso es un upload de un file a un servidor que devolvía un XML con datos). Para hacer esto tenemos varias formas, u opciones, para pasarle al comando curl, como ser –verbose, –trace, o –trace-ascii. Cada una muestra distintas cosas, dependiendo lo que necesitemos. En mi caso, el servidor devolvía el XML con un simple fpassthru, para lo que trace-ascii venía perfecto.

La sintáxis, entonces, sería así:

la aplicación recibió el file a uploadear como si de un form se tratase, y al devolver el XML, curl lo mostró por stdout. Ideal para debuggear desde la terminal en un servidor remoto o sin tener que pasar por la aplicación web.

Dicen por ahí que también es muy útil para testear vulnerabilidades en algunos sitios con poca validación de formularios, pero eso es demasiado oscuro para mí.

hacker sexy tipea un script con 2 joysticks.

Para ver más ejemplos, consulten acá o en el man de curl, por supuesto.

Como es costumbre, todos los veranos Easytech organiza un “día de campo” bien merecido por los developers que tanto sufrimos durante el año (no podemos vivir manejando helicópteros de juguete todo el día).

Para distendernos, fuimos obligados a hacer deporte (terrestre Y ACUÁTICO). Además, no consultamos nuestros mails en todo el día (Bueno, en realidad sí, había Wi-Fi).

En agradecimiento por ese exquisito matambrito a la pizza (y por organizar el evento un día laboral), compartimos las fotos que documentan el hecho:

Un problema recurrente con los sistemas grandes y/o multidominio es mantener la sesion de usuarios entre diferentes dominios.

Es imposible hacerlo con las cookies ya que por cuestiones de seguridad los browser no dejan leer o escribir cookies con diferente dominio al actual.

Lo mismo pasa con las sesiones, si uno accede a una pagina y genera un sesion cuando pasa a otro dominio pierde esa sesion.

La solucion no es nada simple. En el ultimo web and beer se hablo de una solucion, pero esa solucion no me dejo nada convencido, y me quede pensando en la idea.

Actualmente en Easytech estamos trabajando en un proyecto, que inicialmente iba a tener el mismo problema, pero lo solucionamos usando un unico dominio, ya que no era necesario otro. Solo tuvimos que unir varios sistemas, bajo el mismo dominio, pero esto es mucho mas facil, ya que podemos pasar un hash que nos permita buscar la info del usuario en una base de datos o en el file system a traves de las cookies.

Pero este problema de los multidominios tiene solucion, de hecho tenemos un google account, que administra las claves de diferentes dominios, ya sea www.gmail.com, www.google.com, www.youtube.com, www.orkut.com, www.picasaweb.com, etc.. Si google lo resolvio porque no nosotros?

Una manera de resolver este probelma, es guardar los datos de sesion en una base de datos, y los enlaces a los diferentes dominios agregarle el hash que hace de indice en esta base para que pueda regenerar los datos de session. El problema es que si yo accedo directamente a un dominio eso no me va a funcionar muy bien.

Una alternativa a este problema es que todo siempre se redireccione a un dominio, cheque si hay una sesion, y despues redirigirlo, como hace google.

Por ejemplo, cada vez que nosotros accedemos a www.orkut.com, este nos redirecciona a https://www.google.com/accounts/ServiceLogin y envia todos los parametros que necesita para identificar al usuario.

Desde este dominio de autenticacion, generamos la cookie correspondiente con el hash necesario. Y lo volvemos a redireccionar al sitio que quiere acceder con un parametro hash, con el indice para que obtenga los datos.

La solucion parece bastante simple, y creo que lo es pero queria compartirla ya que se me quedo colgada en el ultimo web and beer.

Vamos a ver ahora un ejemplo practico

Yo tengo el dominio www.mail.com, el dominio www.calendar.com, y el dominio de mi empresa que se llama www.cloacas.com.

Un usuario ingresa en www.mail.com, ingresa los datos de su cuenta, este formulario envia un post a http://account.cloacas.com/, valido los datos, genero la autenticacion, y lo redirecciono a http://www.mail.com/?id=1231534232, el dominio mail.com, sabe que tiene que generar la sesion con los datos que va a obtener de la base de datos, con el indice que le paso en id.

Con esto tengo que haber logrado autenticarme en www.mail.com. Ahora el usuario, en otro tab de su browser escribe, www.calendar.com.

Calendar.com, hace lo mismo que www.mail.com, y lo redirecciona a account.cloacas.com, este se fija sino tiene ninguna cookie seteada, y si la tiene busca el hash que guardo en la cookie y la compara con el de la base de datos, si todo esta ok, redirecciona al usuario a www.calendar.com/?id=1231534232, sin la necesidad que el usuario ingrese sus datos, porque ya lo habia hecho en www.mail.com

fuente

Sometimes easytech developers need flying lessons.

After that we got a better kung-fu.