Tuesday, March 25, 2008
Here’s a sneak peek of the Mobshare broadcast widget I’ve been working on. If you look to the right and below, you can see that in action live. You’ll see the last ten pics I’ve uploaded and direct from the widget you can subscribe to my feed or send me an SMS.
The widget is the first released code which uses our internal API. While the API itself is undocumented [which hopefully will soon change], it’s public and it’s JSON (which makes implementing Javascript widgets incredibly easy).
How do you get your own widget? You can’t do that easily right now (the pleasures of cutting-edge code eh?), but paste this code somewhere:
<iframe width="150" height="150" src="http://mobshare.in/user/:mobshare_id:/broadcast/widget"></iframe>
…and change :mobshare_id: to your Mobshare ID.
Try it out and let me know if you like it!
Tags: broadcast • cool • javascript • json • mobshare.in • widget
Comment! |
Permalink
Tuesday, March 18, 2008
I suppose this must be the zillionth post about how Git is so cool, but I’ll tell you what I love about it:
- Ultra fast commits. Coming from subversion, typing commit and getting a prompt back instantly is so surprising that you double check the first few times.
- Branching! God, you don’t realize how much you miss it until you have fast branching and merging. Without the pain of creating
cps, just a simple git checkout -b branch_name and git merge branch_name and everything just works.
- The above was the reason I tried git in the first place. mobME’s an SVN shop and we do the usual trunk, tags, branches dance. When the trunk shapes up to be stable though I can’t seem to do anything on it. I can fork off a new branch in SVN but that’s too painful to even think about. What do I do now?
git clone it, create a branch, and do regular git svn rebases and dcommits.
- Oh did I mention bidirectional SVN support? Without which I wouldn’t/couldn’t have switched no matter how much I wanted to try this cool new thing.
But it’s great and it really changes the way you think about
VCS. Notice something? I didn’t even talk about distributed source control, and that’s coz even when I use git like I use
SVN - committing to a central repo at the end and pulling changes from it, it’s brilliant. I’d definitely want to explore cool stuff like
github soon for personal use (some gracious soul gave me an invite some time back).
Tags: development • git • source control • subversion • sysadmin • vcs
Comments (3) |
Permalink
Saturday, March 8, 2008
I talked about delegating rendering in Symfony for creating a JSON API. Now here’s a consumer: an Orkut opensocial gadget:
MobshareOrkutAPI = {
api_url: 'http://api.mobshare/api.php',
cache_time: 0, //0 to disable
makeCachedRequest: function(url, callback, params, refreshInterval) {
var ts = new Date().getTime();
var sep = "?";
if (refreshInterval && refreshInterval > 0) {
ts = Math.floor(ts / (refreshInterval * 1000));
}
if (url.indexOf("?") > -1) {
sep = "&";
}
url = [ url, sep, "nocache=", ts ].join("");
gadgets.io.makeRequest(url, callback, params);
},
call: function(module, action, params, callback) {
var options = {};
options[gadgets.io.RequestParameters.CONTENT_TYPE] = gadgets.io.ContentType.JSON;
this.makeCachedRequest(this.api_url + '/' + module + '/' + action + '?' + params, callback, options, this.cache_time);
}
};
makeCachedRequest has been plaigarized from the Opensocial documentation and it’s very useful to bust the cache for requests. Also, notice this line for setting the content-type to JSON:
options[gadgets.io.RequestParameters.CONTENT_TYPE] = gadgets.io.ContentType.JSON;
This is how we access that API, a code fragment:
...
authenticate: function(alias, mobile_no, password) {
MobshareOrkutAPI.call('user', 'authenticate',
'alias=' + encodeURIComponent(alias) + '&mobile_no=' + encodeURIComponent(mobile_no) +
'&password=' + encodeURIComponent(password),
MyOrkutApp.login
);
}
...
login: function(orkut_response) {
response = orkut_response.data;
data_success = response['success'];
data_error = response['error'];
if(data_success) {
html = '<h2>Login Successful!</h2>';
html += '<p>Welcome: ' + data_success.name + '!</p>';
} else if(data_error) {
html = '<h2>Login Unsuccessful!</h2>';
html += '<p>' + data_error + '!</p>';
}
document.getElementById('mobshare_login').innerHTML += html;
},
...
Note that orkut_response.data is automatically set by Orkut because you passed in the JSON content type; it parses the data received and creates a javascript object. Cool, ain’t it? It’s very easy to create a proper interactive Opensocial app this way.
Tags: api • application • development • javascript • json • opensocial • orkut • web
Comment! |
Permalink
Thursday, March 6, 2008
Warning: pretty advanced Symfony ahead: if you’re not familiar with the framework, this wouldn’t make sense.
I recently developed a bare-bones API for Mobshare (it’s not yet live), and to keep everything clean, I abstracted away the rendering bit from the controller to an external class. It ended up being a sweet solution, so here it is!
I wanted this to be a JSONP API (the major use case would be a JS client, and parsing XML etc. via JS is a pain. Besides JSON is much shorter over the wire). I didn’t want to rewrite a lot of code: checking for a callback parameter and wrapping the returned string around the JSON output was just begging to be refactored away. So here it is, a generic Symfony JSON API wrapper class:
<?php
class JSONPAPI {
const CALLBACK_PARAMETER = 'callback';
var $status;
var $data;
var $callback;
public function __construct($status, $data) {
$this->status = $status;
$this->data = $data;
$callback_parameter_value = $this->getCurrentAction()->getRequestParameter(self::CALLBACK_PARAMETER);
if($callback_parameter_value)
$this->callback = $callback_parameter_value;
}
public function render() {
$render_text = json_encode(array($this->status => $this->data));
if($this->callback)
$render_text = $this->callback . '(' . $render_text . ');';
$this->setJavascriptHeaders();
return $this->getCurrentAction()->renderText($render_text);
}
//hack to get the current action
private function getCurrentAction() {
return sfContext::getInstance()->getActionStack()->getLastEntry()->getActionInstance();
}
private function setJavascriptHeaders() {
sfContext::getInstance()->getResponse()->setParameter('Content-Type', 'application/javascript', 'symfony/response/http/headers');
}
}
The bits of magic here are the getCurrentAction() function and the render() call. It works on one very simple idea: everything in Symfony can be accessed from the sfContext::getInstance() object, you just need to dig deep enough.
Once you write this boiler-plate code, using it is very elegant. First, subclass it for your API:
<?php
require_once('JSONPAPI.class.php');
class MobshareAPI extends JSONPAPI {
}
And then, use it like so within your controller:
<?php
class userActions extends sfActions
{
public function executeAuthenticate() {
$valid_user = UserPeer::authenticate($this->getRequestParameter('alias'),
$this->getRequestParameter('mobile_no'), $this->getRequestParameter('password'));
if($valid_user instanceOf User) {
$success = new MobshareAPI('success', $valid_user->toArray());
return $success->render();
} else {
$error = new MobshareAPI('error', 'Authentication failed: Alias, mobile number or password invalid.');
return $error->render();
}
}
}
Note: the rendering has been delegated to the $success and $error MobshareAPI objects. This allows for a really maintainable API. Adding functionality is much simpler since you don’t have to worry about the boilerplate.
You end up calling the API like this:
http://api.mobshare/user/authenticate?alias=vish&password=xxx&callback=handler
and you get back data which looks like this:
handler({"success":{"alias":"vish","name":"Vishnu Gopal","photo_mini": ...);
Note that callback handling is done entirely by the API and the controller needn’t worry about this parameter at all!
Tags: api • cool • development • json • jsonp • PHP • symfony • web
Comments (4) |
Permalink
Tuesday, March 4, 2008
Most people use GNU screen (or equivalent) to daemonize processes. There is a better alternative called dtach which should become the definitive way to run a process in the background as a daemon.
Installing dtach is easy. If you’re on gentoo, it is a simple:
$ emerge dtach
dtach --help provides the following output:
Usage: dtach -a <socket> <options>
dtach -A <socket> <options> <command...>
dtach -c <socket> <options> <command...>
dtach -n <socket> <options> <command...>
Modes:
-a Attach to the specified socket.
-A Attach to the specified socket, or create it if it
does not exist, running the specified command.
-c Create a new socket and run the specified command.
-n Create a new socket and run the specified command detached.
This basically means that you start dtach like so:
$ dtach -c ~/rtorrent/.socket/dtach rtorrent
The command-shortcut Ctrl+\ detaches the running command and runs it in the background. To re-attach, just enter:
$ dtach -a ~/rtorrent/.socket/dtach
dtach hasn’t got much more functionality, but that’s what makes it superb. Tiny and functional. As you can see, I’m using dtach to run a Seedbox 
Tags: *nix • applications • sysadmin
Comment! |
Permalink
