The site was actually live and functional last week, but today saw some graphic and interface updates that make things quite a bit more presentable!

1. Ability to send parameters with requests
2. Ability to send multiple requests

The first was actually fairly simple to fix – once you understand that not only do the auth parameters go into generating the request signature, but the request parameters also must be part of the signature or the request will fail. Took a little trial and error to figure this out and the code change was very simple to put into effect.

The second item was tricky, since I could send one request and it would work but any subsequent requests always failed. For a few hours, I assumed that the second request failed and I was using the API wrong. Once I only sent that request, it worked fine – which led to the revelation that my class used the same $oauth array for signature calculation and request generation. That was ok, but after the first request, the signature had been added to the array. Any subsequent request would then include the old signature value in the new signature generation and then replace the old value in the array. This meant that the signature would be invalid. Once I deduced the nature of the problem, solving it was simple.

I redeveloped the code into a php class to make it modular and easier to work with which I’m happy to share.

The class starts by defining the key variables (such as the application tokens) as well as the constructor – which accepts the user tokens we are making requests on behalf of.

class tapi {
  var $consumer_key = ‘CONSUMER_KEY_HERE;
  var $consumer_secret = ‘CONSUMER_SECRET_HERE’;
  var $access_token;
  var $access_secret;
  var $oauth;

  function tapi($token, $secret) {
    $this->access_token = $token;
    $this->access_secret = $secret;

    $this->oauth = array(
      'oauth_consumer_key' => $this->consumer_key,
      'oauth_token' => $this->access_token,
      'oauth_signature_method' => 'HMAC-SHA1',
      'oauth_timestamp' => time(),
      'oauth_nonce' => time(),
      'oauth_version' => '1.0'
    );
  }

This is followed by two key methods from ErisDS which do a nice job building the request url and the authorization header:

  function build_url($request, $params) {
    $url = "http://api.twitter.com/1/$request";
    if(count($params)) {
      $query = array();
      foreach($params as $key=>$value)
        $query[] = "$key=" . rawurlencode($value);

      $url .= '?' . implode('&', $query);
    }

    return $url;
  }

  function build_authorization_header()
  {
    $r = 'Authorization: OAuth ';
    $values = array();
    foreach($this->oauth as $key=>$value)
        $values[] = "$key=\"" . rawurlencode($value) . "\"";

    $r .= implode(', ', $values);
    return $r;
  }

Then I’ve added a convenience method to build the base string that is used when generating the signature. And I’ve created a build signature method from the ErisDS code. The difference is that I’m also allowing parameters to be included in the request. Also note that the “oauth_signature” element from the parameter array is ignored when building the base string. This is the fix for the subsequent request failure issue I mentioned above.

  function build_base_string($request, $method, $params)
  {
    $r = array();
    ksort($params);
    foreach($params as $key=>$value){
      if($key == "oauth_signature") continue;
      $r[] = "$key=" . rawurlencode($value);
    }

    return $method."&".rawurlencode("http://api.twitter.com/1/$request").'&'.
      rawurlencode(implode('&', $r)); //return complete base string
  }

  function build_signature($request, $params) {
    $all_params = array_merge($params, $this->oauth);
    $base_info = $this->build_base_string($request, 'GET', $all_params);

    $composite_key = rawurlencode($this->consumer_secret) . '&' .
      rawurlencode($this->access_secret);
    $oauth_signature = base64_encode(hash_hmac('sha1', $base_info,
      $composite_key, true));
    $this->oauth['oauth_signature'] = $oauth_signature;
  }

The most important method is send_request which takes the request and parameters and builds the url, generates the signature, sends the request and returns the result.

  function send_request($request, $params) {
    $url = $this->build_url($request, $params);
    $this->build_signature($request, $params);

    $header = array($this->build_authorization_header(), 'Expect:');
    $options = array( CURLOPT_HTTPHEADER => $header,
                  CURLOPT_HEADER => false,
                  CURLOPT_URL => $url,
                  CURLOPT_RETURNTRANSFER => true,
                  CURLOPT_SSL_VERIFYPEER => false);
    $feed = curl_init();
    curl_setopt_array($feed, $options);
    $json = curl_exec($feed);
    curl_close($feed);

    $twitter_data = json_decode($json);
    return $twitter_data;
  }

The class is essentially complete but I decided that I wanted helper methods for the different requests so I can default parameters and make the request as dummy proof as possible. Here are a few examples:

  function verify_credentials() {
    $request = "account/verify_credentials.json";
    $params = array();

    $result = $this->send_request($request, $params);
    return($result);
  }

  function user_lookup($list) {
    $request = "users/lookup.json";
    $params = array('user_id'=>$list);
    // where list is a comma delimited list of twitter ids – up to 100

    $result = $this->send_request($request, $params);
    return($result);
  }

The entire class is available for download here: tapi.zip. Hope someone else finds it useful.

Business plan! Escrow accounts for your Twitter followers. When your account gets suspended, and they blink, and reinstate you, it auto-adds your followers back..

I’ve been asked to develop this exact solution for someone who fears they might be FABanned (Fake Abuse Banned…pretty weak, but it’s Monday and the coffee hasn’t taken effect yet). If others are interested, I can offer it as an affordable service.

The way it will work (at least in my initial design) is it will use a read-only app to grab an account’s followers and friends and then zip them up in two formats and email them to the user at some interval…probably once a day. There will be a machine readable format and a human readable version. With the machine readable, it would be possible to automatically re-update the friends list using a app with write permissions. I’m not sure if we can add followers back, but it might be possible to automatically tweet them to let them know that they are no longer following you.

If that sounds interesting to you, email me or post a comment on this post.

Ed

UPDATE: I’ve got the service up and running now at Nestwork.net. Site development has been put on hold until I could get the backup functionality in place, so it isn’t a pretty place but the backups work!

(Or unhappy, if you owe much money.)

It might make you feel better to know that you are not alone! Even at 240 miles above the surface of the earth, it is still tax day outside the earth’s atmosphere…at least for a few Astronauts.

No that didn’t make me feel better either.

Anyone who has submitted mobile apps to the Apple App Store, knows that it can be a nerve wracking experience. Too much of the last 3 weeks has been spent preparing, submitting, reworking and biting fingernails through the process. Tremendous relief came yesterday when the app was finally approved. (If you are interested, you can get it here!)

One more app left to develop for Twitchy…so I’d better get back to that.

The cause is this: When you auto update either WordPress or plugins, WordPress creates a temporary file in the WordPress root so users can’t access the site for a few minutes while the update is performed. Pretty good idea, but if the update fails or for some reason the file is never removed, then both the site and the WordPress backend are not accessible to anyone.

The fix is pretty simple: remove the file and everything will be better again (although if you were doing a WordPress upgrade and it failed, your site may be in an unstable state or your database might still require conversion to the latest version).

The file that needs removing is called .maintenance (note the preceeding dot – it is important) and should reside in the WordPress root directory (where index.php and wp-content reside). Connect via ssh or ftp and remove this file and the site should be back online.

One other note – the preceeding dot on the filename makes it not show in a file listing (at least on Linux). Use ls -la to show *ALL* files including those that start with a period.

Today we’re introducing Account Activity, a new feature in your Google Account. If you sign up, each month we’ll send you a link to a password-protected report with insights into your signed-in use of Google services.

First month, it doesn’t tell you much but I can see that a few months down the road, comparing months might be interesting.  My current activity is:

• Emails sent: 1,864 (to 1523 contacts)
• Emails received: 1,136 (from 223 contacts)

I guess that is only 62 emails a day, on average. How do I ever get any work done?

• Typographer’s Glossary
  All you ever wanted to know about typography, and more. I really need to read through this in its entirety at some point.
• Using Modernizr…
  Modernizr is a javascript library that detects CSS and HTML5 functionality. Neat way to develop a page that doesn’t waste resources on things that won’t show up anyways.
• HTML5 Async Scripts
  I need to test this and see which browsers this helps on, but if speeding up sites is this easy, that is a win for everyone. (Or maybe I should have kept this a secret to make my skills in more demand…Meh – not my style.)
• How Cowbird Transforms Storytelling on the Web
  Never heard of cowbird before but they have a pretty cool presentation.
• No ‘pull-to-refresh’ in native iOS apps
  The pull-to-refresh function was patented by Tweetie, which was later purchased by Twitter. Hope they don’t go after indie developers with big lawyers!

Posting has been light mostly because I’ve been heads down on a few new apps for a new site that just launched today.

Twitchy is a Twitter aggregation site with actual humans doing the aggregation. The site works great, which I unfortunately cannot take any credit for.

What I can take credit for is the new android app available here: Twitchy Android.

I had to deal with a server outage this morning and the culprit was a few slow queries running multiple times per second on a site that I host. The cause turned out to be a WordPress plugin that provides good functionality but did not use any indexes on its tables. There is no doubt in my mind that a significant number of plugins are out there that suffer from the same inefficiencies.

Here is the mysql-slow log entry for one of the queries:

# Time: 120214 10:16:04
# User@Host: db_user[db_name] @ localhost []
# Query_time: 5.142186  Lock_time: 0.000077 Rows_sent: 1  Rows_examined: 145277
SELECT SUM('clicks') as 'clicks', SUM('impressions') as 'impressions' FROM 'wp_adrotate_stats_tracker' WHERE 'ad' = '591';

What this means is that this query that sums the number of ‘clicks’ from the stats_tracker table for ad ‘591’ is taking over 5 seconds to execute and examines more than 145 thousand rows in order to determine the result. I was certain that ad number 591 didn’t have 145,000 rows attributed to it so the first thing I did was add a new index to the table:

CREATE INDEX ad_idx ON wp_adrotate_stats_tracker (ad);

That is how you do it from the command line; it is even easier in phpMyAdmin. After that, I issued the same query with ‘Explain’ in front of it, and it revealed that the query now examine a mere 700 rows – 0.4% of the records examined sans index.

Here is another example:

# Time: 111007  9:01:19
# User@Host: db_user[db_name] @ localhost []
# Query_time: 8.488923  Lock_time: 0.000106 Rows_sent: 1  Rows_examined: 49715
SELECT COUNT(*) FROM 'wp_adrotate_tracker' WHERE 'ipaddress' = '66.249.72.14' AND 'stat' = 'i' AND 'timer' < '1317999371' AND '>bannerid' = '55' LIMIT 1;

Examining 49,000 rows seems a bit high and ip address seems pretty specific, so I tried adding another index:

CREATE INDEX ip_idx ON wp_adrotate_tracker (ipaddress);

Any guesses at the number of rows the query had to examine now? The answer is 49714 less than without the index – one single row (or if you prefer percentages…the query now consults 99.998% fewer rows than without the index).

The best thing about indexes is that even if the developer fails to foresee and add them, the end user can add them manually and they still work. (That’s what I did!)

If you want to learn more about indexes, here are a couple of solid links with great information:

• DatabaseJournal: Optimizing MySQL Queries and Indexes
• Mysql.com: Mysql Indexes