The following lines of code are all you need for have all celery workers logs on a syslog server

import logging
from celery.signals import after_setup_logger, after_setup_task_logger

def after_setup_logger_handler(sender=None, logger=None, loglevel=None,
                               logfile=None, format=None,
                               colorize=None, **kwds):
    handler = logging.handlers.SysLogHandler(address=('syslogserver', 514))
    handler.setFormatter(logging.Formatter(format))
    handler.setLevel(logging.INFO)
    logger.addHandler(handler)

after_setup_logger.connect(after_setup_logger_handler)
after_setup_task_logger.connect(after_setup_logger_handler)

As you can see I added the same handler to bot signal, this because I need to add it to every task logger and to every global logger (Worker, Main Process).
Just pay attention to don’t connect the handler to the signal more than one time or you will have duplicate logs, for this reason don’t put this code in a configuration file but in a separated module that you are sure is included only one time.
Probably you want also to have a separated file for you celery logs on your rsyslog server, it’s enough to add a filter on the IP of your celery workers:

if $fromhost-ip startswith '192.0.2.' then /var/log/celery_central.log
& ~
if $fromhost-ip startswith '192.0.3.' then /var/log/celery_central.log
& ~

Don’t forget to put this rules before all the others and to enable the receiving of remote logs on your rsyslog confing file.
Off course here I’m using a syslog handler but you can extend logs in many ways at the end is just Python .

Europython 2011 – Playing tasks with Django & Celery from Mauro Rocco on Vimeo.

.

Slides

Well, before continuing for have a good test case I suggest you to publish some hits on the mturk sandbox and do it trough the workers sandxbox, in this way you will have some results ready to be fetched.
The protagonist of this tutorial is the method get_reviewable_hits,

get_reviewable_hits(hit_type=None, status=’Reviewable’, sort_by=’Expiration’, sort_direction=’Ascending’, page_size=10, page_number=1)

as you can understand by the name this method fetch the hits that have the status of “reviewable” or “reviewing” this means all the hits that have all assignments (Number of answer required from different workers) completed or that are expired.
As you can also understand from parameters this method give you back by default just the first 10 reviewable hits, the maximum page size that you can have is 100, this means that if you have more than 100 hits ready you have to call this method more than one time with incremental page number.
Well, the first thing that we do is write a method that fetches all reviewable hits, it accept as unique parameter an mturk connection object.

def get_all_reviewable_hits(mtc):
    page_size = 50
    hits = mtc.get_reviewable_hits(page_size=page_size)
    print "Total results to fetch %s " % hits.TotalNumResults
    print "Request hits page %i" % 1
    total_pages = float(hits.TotalNumResults)/page_size
    int_total= int(total_pages)
    if(total_pages-int_total>0):
        total_pages = int_total+1
    else:
        total_pages = int_total
    pn = 1
    while pn < total_pages:
        pn = pn + 1
        print "Request hits page %i" % pn
        temp_hits = mtc.get_reviewable_hits(page_size=page_size,page_number=pn)
        hits.extend(temp_hits)
    return hits

The list of hits returned by the method is a list of boto HITS objects.
This object doesn’t contain the assignments, you have to call another method for get the assignments of a particular HIT id.
The next step is tho iterate trough this list and for each HIT calls the method get_assignments(hit_id)

This method will return all the answers to your hits.
Below the complete script for print to screen all the assignments of your hits.

from boto.mturk.connection import MTurkConnection

ACCESS_ID ='your access id'
SECRET_KEY = 'your key'
HOST = 'mechanicalturk.sandbox.amazonaws.com'

def get_all_reviewable_hits(mtc):
    page_size = 50
    hits = mtc.get_reviewable_hits(page_size=page_size)
    print "Total results to fetch %s " % hits.TotalNumResults
    print "Request hits page %i" % 1
    total_pages = float(hits.TotalNumResults)/page_size
    int_total= int(total_pages)
    if(total_pages-int_total>0):
        total_pages = int_total+1
    else:
        total_pages = int_total
    pn = 1
    while pn < total_pages:
        pn = pn + 1
        print "Request hits page %i" % pn
        temp_hits = mtc.get_reviewable_hits(page_size=page_size,page_number=pn)
        hits.extend(temp_hits)
    return hits

mtc = MTurkConnection(aws_access_key_id=ACCESS_ID,
                      aws_secret_access_key=SECRET_KEY,
                      host=HOST)

hits = get_all_reviewable_hits(mtc)

for hit in hits:
    assignments = mtc.get_assignments(hit.HITId)
    for assignment in assignments:
        print "Answers of the worker %s" % assignment.WorkerId
        for question_form_answer in assignment.answers[0]:
            for key, value in question_form_answer.fields:
                print "%s: %s" % (key,value)
        print "--------------------"

As you can see the scripts call the get_assignments method for each hit id and after that iterate trough it for fetching the answers.
In the line 36 you see an answer[0], maybe you are thinking “why don’t iterate trough all answers ?”
For try to give a clear explanation first let’s give some definition thaw will be valid on the next rows.

• A “question form answer” is the single answer to a single question of your form.
• An “answer” element is the set of all the “question form answer” of your QuestionForm
• An “assignment” is the set of all the “answers” of the same worker

In practice each worker can give just 1 “answer” to the hit, for that the assignment will contain always just one “answer”.
“answers” element is just a reflection of the xml structure, boto translate it as array of one element.
If this explanation has been clear, you just have to know which method use for accept and refuse payments to the workers.
The operations of pay and refuse have do be done on the “assignments” unit, in fact they accept the assignment id as a parameter.

approve_assignment(assignment_id, feedback=None)

reject_assignment(assignment_id, feedback=None)

Both methods accept also a feedback string, this is the message that the workers will receive as explanation for the approved/rejected assignment, be kind .
When you don’t need anymore an hits you can “delete” it from mturk by calling the method

disable_hit(hit_id, response_groups=None)

I suggest you to read the documentation about disable_hit method.
I leave you with an edited version of the loop that pay all workers and disable the hits.
See you soon

for hit in hits:
    assignments = mtc.get_assignments(hit.HITId)
    for assignment in assignments:
        print "Answers of the worker %s" % assignment.WorkerId
        for question_form_answer in assignment.answers[0]:
            for key, value in question_form_answer.fields:
                print "%s: %s" % (key,value)
        mtc.approve_assignment(assignment.AssignmentId)
        print "--------------------"
    mtc.disable_hit(hit.HITId)

Boto library (2.0b4): you can install it with easy_install or download the package from the github page.
Amazon Web Services keys: create an account or login if you already have one on aws.amazon.com, after that go to you account admin panel and than security settings.
In the page scroll to the section Access credentials and keep note of the Access Key ID and Secret Access Key.

We are almost ready for use this keys with Boto but before that we have to login with the aws account on https://requestersandbox.mturk.com/ for create the Mturk Sandbox account.

Ok, now we can start to write some code for test if our keys work and if we can connect to the Mturk engine.
Below there is the code for connect to the mturk api and get the account balance.

from boto.mturk.connection import MTurkConnection

ACCESS_ID ='your access key'
SECRET_KEY = 'your secret key'
HOST = 'mechanicalturk.sandbox.amazonaws.com'

mtc = MTurkConnection(aws_access_key_id=ACCESS_ID,
                      aws_secret_access_key=SECRET_KEY,
                      host=HOST)

print mtc.get_account_balance()

The expected result is a list with one value, normally $10,000.00 (I never see numbers like this on my bank account )

If everything works fine we can start to create an mturk HIT.
Basically an HIT is a question, or a collection of questions. I strongly suggest you to read the HIT Data Structure before continue with this tutorial.

Let’s start to create our first HIT with 2 questions:
1 mandatory with choices and another one not mandatory with a free text answer.

from boto.mturk.connection import MTurkConnection
from boto.mturk.question import QuestionContent,Question,QuestionForm,
Overview,AnswerSpecification,SelectionAnswer,FormattedContent,FreeTextAnswer

ACCESS_ID ='your acces key'
SECRET_KEY = 'your secret key'
HOST = 'mechanicalturk.sandbox.amazonaws.com'

mtc = MTurkConnection(aws_access_key_id=ACCESS_ID,
                      aws_secret_access_key=SECRET_KEY,
                      host=HOST)

title = 'Give your opinion about a website'
description = ('Visit a website and give us your opinion about'
               ' the design and also some personal comments')
keywords = 'website, rating, opinions'

ratings =[('Very Bad','-2'),
         ('Bad','-1'),
         ('Not bad','0'),
         ('Good','1'),
         ('Very Good','1')]

#---------------  BUILD OVERVIEW -------------------

overview = Overview()
overview.append_field('Title', 'Give your opinion on this website')
overview.append(FormattedContent('<a target="_blank"'
                                 ' href="http://www.toforge.com">'
                                 ' Mauro Rocco Personal Forge</a>'))

#---------------  BUILD QUESTION 1 -------------------

qc1 = QuestionContent()
qc1.append_field('Title','How looks the design ?')

fta1 = SelectionAnswer(min=1, max=1,style='dropdown',
                      selections=ratings,
                      type='text',
                      other=False)

q1 = Question(identifier='design',
              content=qc1,
              answer_spec=AnswerSpecification(fta1),
              is_required=True)

#---------------  BUILD QUESTION 2 -------------------

qc2 = QuestionContent()
qc2.append_field('Title','Your personal comments')

fta2 = FreeTextAnswer()

q2 = Question(identifier="comments",
              content=qc2,
              answer_spec=AnswerSpecification(fta2))

#--------------- BUILD THE QUESTION FORM -------------------

question_form = QuestionForm()
question_form.append(overview)
question_form.append(q1)
question_form.append(q2)

#--------------- CREATE THE HIT -------------------

mtc.create_hit(questions=question_form,
               max_assignments=1,
               title=title,
               description=description,
               keywords=keywords,
               duration = 60*5,
               reward=0.05)

If you don’t see any output everything worked well, for be sure navigate to https://workersandbox.mturk.com/ and see if your hit is in the list (can take some time to appear, you can also check on the requester sandbox admin panel).
The code is very clear and self explained but I will give you anyway some description with links to the Boto DOCS.

Overview: The overview is a free content of the question form, this means that can be everything (binary content, an html content, ex.), remember that it isn’t a “question object” is just an arbitrary content, in my example is a link to the website.
http://boto.cloudhackers.com/ref/mturk.html#boto.mturk.question.Overview

Question: The question is mainly made by the AnswerSpecification object, that specify which kind of answer have to be rendered for the question and by the QuestionContent object. The content can be, like for the Overview, a text, a binary content, an html content, ex.
http://boto.cloudhackers.com/ref/mturk.html#boto.mturk.question.Question
http://boto.cloudhackers.com/ref/mturk.html#boto.mturk.question.AnswerSpecification
http://boto.cloudhackers.com/ref/mturk.html#boto.mturk.question.QuestionContent

QuestionForm: This is the container for all your questions and overviews, basically is an extension of a python standard list.
http://boto.cloudhackers.com/ref/mturk.html#boto.mturk.question.QuestionForm

create_hit method: This is the method for create an hits, for see which parameters it accepts take a look to the docs.
A little suggestion, the question and questions parameters are different, the first one accept a Question object if you want to create a hit with just a question, the second one accept a QuestionForm.
http://boto.cloudhackers.com/ref/mturk.html#boto.mturk.connection.MTurkConnection.create_hit

Well, now you should be able to create an hit, you can also do your hits on the worker sandbox for see how they works and for have some results to fetch.
In the next tutorial I will speak about fetching result from your hits and accept or refuse payments to the workers.
See you soon

• Support for before Christ dates.
• Set a custom before and after Christ suffix string
• Build the timeline only with posts from one or more categories.
• Exclude single posts or pages from the timeline.
• Choose the date input format with a dropdown menu.
• Choose the output format of the date and the timeline order.
• The CSS is customizable from the admin area of the plugin.

Download it and enjoy, for any problem or bug report don’t hesitate to contact me.
You can download the plugin from here:
http://historytimeline.toforge.com

I think that for the next release, after some bug-fix, I will implement a JQuery look and feel too.
If you have some additional idea just write a comment.

The sandbox is wrote as a Context Manager (under suggestion of asksol ) with an entry point that will create the folders and an exit point that will clean it.
The class create a folder structure like this:

/sandboxradix/tasks.mytask.dosomething/taskpid/

On the exit point only the taskpid folder will be erased, in this way you can launch several tasks of the same type at the same time
Let’s see how you can use it for you celery task.

In my personal opinion the best way to do it is to create a base class for all your tasks that extend the celery task class and inside it implement some general useful methods like the sandbox behaviour.
Following you can see an example of a general base class that use my sandbox context manager.

import settings
from celery.task import Task
from sandBox import SandBox

class toforgeTask(Task):

    def __call__(self, *args, **kwargs):
        """In celery task this function call the run method, here you can
        set some environment variable before the run of the task"""

        self.sandbox = SandBox(self.name, self.request.id,
                               settings.PATH_SANDBOX)
        return self.run(*args, **kwargs)

    def after_return(self, status, retval, task_id, args, kwargs, einfo):
        #: If the sandbox is initialized we clean it
        if self.sandbox.isInitialized():
            self.sandbox.__exit__()

    def run(self):
        return "This is a Base Task Class not runnable"

As you can read on the comments the __call__ method is called before the task execution.
Here we call the constructor of our sanbox but we don’t initialize it because maybe not all our tasks needs sandbox .
For the same reason in the method after_return, called form celery at the end of a task whatever is the status (RETRY,FAILURE, ecc.), we will clean the sandbox only if we used it.
The settings module that you see in my general task is the django settings that I use for store conf vars from my task like the PATH_SANDBOX the radix folder for your sandbox.

Now you can write a task by extend the base task that we created and maybe it will look like this

from toforgeTask import toforgeTask

class sampleDownloader(toforgeTask):

    def run(self, album_id, **kwargs):
        self.logger.info("Download a test file %s " % (album_id))

        #: initialize tha sanbox
        self.sandbox.__enter__()

        #: download a file
        self.writeFileFromUrl(self,"http://www.toforge.com/notexistfile.zip",
                              "myfile")

        #: do some stuff with the file in the sandbox
        #: you can open files in the standard way just use
        #: the self.sandbox.path variable

        return """File downloaded, but you will not found it because at the
               end of the task the sandbox will be cleaned"""

Following you can see the source code of the protagonist of this post, the sandBox.py file.

import errno
import os
import shutil
import urllib2

class SandBox(object):
    """A simple sandbox context manager for easy create and clean of a
    sandbox folder plus some useful methods for file download and write

    Mauro Rocco

http://www.toforge.com

    """

    def __init__(self, name, id, prefix, debug = False):

        #: name of the folder, commonly the name of the task
        self.name = name

        #: pid of the task, the name of the end folder where the sandbox
        #: writes the files
        self.id = id

        #: the base path for your sandbox
        self.prefix = prefix

        #: te complete path used in the context
        self.path = None

        #: debug option for print some output information
        self.debug = debug

    def __enter__(self):
        self.path = os.path.join(self.prefix, self.name, self.id)

        try:
            os.makedirs(self.path)
        except OSError, exc:
            if exc.errno != errno.EEXIST:
                raise

        return self

    def __exit__(self, *exc_info):
        try:
            shutil.rmtree(self.path)
        except OSError, exc:
            if exc.errno != errno.ENOENT:
                raise

    def _debugPrint(self,message):
        if self.debug:
            print message

    def _createFile(self, fileName, mode, override = False):
        if not self.isInitialized():
            self.__enter__()

        if override:
            return open(os.path.join(self.path,fileName), mode)
        try:
            open(os.path.join(self.path,fileName))
        except IOError, exc:
            if exc.errno == errno.ENOENT:
                return open(os.path.join(self.path,fileName), mode)
            raise
        raise Exception("File already exist in sandbox: %s "
                        % (os.path.join(self.path,fileName)))

    def isInitialized(self):
        """Check if the sandbox is initialized"""
        if self.path:
            return True
        return False

    def getSandboxContent(self):
        """Return a list of all folders and files
        in the current sandbox folder"""
        if not self.isInitialized():
            self.__enter__()
        tree = []
        for dirname, dirnames, filenames in os.walk(self.path):
            for subdirname in dirnames:
                tree.append(os.path.join(dirname, subdirname))
            for filename in filenames:
                tree.append(os.path.join(dirname, filename))
        return tree

    def writeFile(self,content, fileName, mode = "w", override = False):
        """write a file in the sandbox folder"""
        f = self._createFile(fileName, mode, override)
        f.write(str(content))
        f.close()

    def writeFileFromUrl(self,url,fileName, override = False, httpproxy=None,
                         ftpproxy=None, gopherproxy=None):
        """Download a file from the given url  and write it
         on the sandbox with the given name"""
        proxies={}

        if httpproxy:
            proxies["http"]=httpproxy

        if ftpproxy:
            proxies["ftp"]=ftpproxy

        if gopherproxy:
            proxies["gopher"]=gopherproxy

        outfile=self._createFile(fileName, "wb", override)

        proxy = urllib2.ProxyHandler(proxies)
        opener = urllib2.build_opener(proxy)
        urllib2.install_opener(opener)

        instream = urllib2.urlopen(url)
        length = instream.info().getheader("Content-Length")

        if length==None:
            length="?"

        self._debugPrint("Downloading %s (%s bytes) ..."
                         % (instream.url, length))

        bytesRead=0.0

        for line in instream:
            bytesRead+=len(line)
            outfile.write(line)

            if length!="?":
                self._debugPrint("Downloading... %.02f/%.02f kb (%d%%)"
                                 % (fileName,
                                    bytesRead/1024.0,
                                    length/1024.0,
                                    100*bytesRead/length))

        instream.close()
        outfile.close()
        self._debugPrint("File downloaded successful")

Enjoy

$ sudo apt-get smartdimmer

For test if the module works just try to set a new brightness value by typing

$ smartdimmer -s 50

If the module works for your laptop you can use the following script for change brightness directly from your keyboard.

File: brightness.sh

#!/bin/bash
maxbrightness=95
curbrightness=$(smartdimmer --get | grep -o [0-9][0-9][0-9]*)
let brightness=$curbrightness
let factor=5

if [ $# -gt 0 ]; then
 if [ $1 = "+" ]; then
 if [ $curbrightness -lt $maxbrightness ]; then
 let brightness=$brightness+$factor;
 fi
 fi

 if [ $1 = "-" ]; then
 if [ $curbrightness -gt 20 ]; then
 let brightness=$brightness-$factor;
 fi
 fi
fi

smartdimmer --set $brightness

Now put this script in your home directory and use the tool Preferences -> Keyboard Shortcut for associate the preferred keys to the following commands.

Increase brightness: brightness.sh +
Decrease brightness: brightness.sh -

Hi folks, today I want to share with you this very useful phonegap‘s plug-in.
As the title says this plug-in allow you to download a file (url) on the sd card in the folder of your choice.

Usage

downloader.downloadFile(fileUrl,dirName,fileName,overwrite,win,fail);

Params

fileUrl: <String> The url of the file to download
dirName: <String> The directory where you want to save the file
fileName: <String> The name of the file
overwrite: <Boolean> Overwrite the file if exist
win: <Function> Success callback function. Receive a parameter that contains the fileName if the file is wrote with success.  If the overwrite parameter is false and the file already exist the parameter will contain the string “exist”.
fail: <Function> Fail callback function. Receive a parameter that contains the error message

Source and installation

Like all phonegap android plugins is composed by tha java file and the javascript one.
For starting using this plugin first copy the java file into the java src folder of your android project, in my example  the package is called com.example.pgplugins.DownloaderPlugin.

File: Downloader.java

package com.example.pgplugins.downloaderPlugin;

/*
 @author Mauro Rocco http://www.toforge.com
*/

import org.json.JSONArray;
import org.json.JSONException;

import android.util.Log;

import com.phonegap.DroidGap;
import com.phonegap.api.Plugin;
import com.phonegap.api.PluginResult;

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.net.HttpURLConnection;
import java.net.URL;

public class Downloader extends Plugin{

 @Override
 public PluginResult execute(String action, JSONArray args, String callbackId) {
 if (action.equals("downloadFile")) {
 try {
 return this.downloadUrl(args.getString(0),args.getString(1),args.getString(2),args.getString(3));
 } catch (JSONException e) {
 return new PluginResult(PluginResult.Status.ERROR, "Param errrors");
 }
 }
 else {
 return new PluginResult(PluginResult.Status.INVALID_ACTION);
 }

 }

 private PluginResult downloadUrl(String fileUrl, String dirName, String fileName, String overwrite){
 try{
 Log.d("DownloaderPlugin", "DIRECTORY CALLED /sdcard/"+dirName+" created");
 File dir =     new File("/sdcard/"+dirName);
 if(!dir.exists()){
 Log.d("DownloaderPlugin", "directory /sdcard/"+dirName+" created");
 dir.mkdirs();
 }

 File file = new File("/sdcard/"+dirName+fileName);

 if(overwrite.equals("false") && file.exists()){
 Log.d("DownloaderPlugin", "File already exist");
 return new PluginResult(PluginResult.Status.OK, "exist");
 }

 URL url = new URL(fileUrl);
 HttpURLConnection ucon = (HttpURLConnection) url.openConnection();
 ucon.setRequestMethod("GET");
 ucon.setDoOutput(true);
 ucon.connect();

 Log.d("DownloaderPlugin", "download begining");

 Log.d("DownloaderPlugin", "download url:" + url);

 InputStream is = ucon.getInputStream();

 byte[] buffer = new byte[1024];

 int len1 = 0;

 FileOutputStream fos = new FileOutputStream(file);

 while ( (len1 = is.read(buffer)) > 0 ) {
 fos.write(buffer,0, len1);
 }

 fos.close();

 Log.d("DownloaderPlugin", "Download complete in" + fileName);

 } catch (IOException e) {

 Log.d("DownloaderPlugin", "Error: " + e);
 return new PluginResult(PluginResult.Status.ERROR, "Error: " + e);

 }

 return new PluginResult(PluginResult.Status.OK, fileName);

 }

}

Now copy the following javascript file in the assets/www folder, remember to change the name of the package or the js will never found the java file.

File: downloader.js

function Downloader() {

}

Downloader.prototype.downloadFile = function(fileUrl,dirName,fileName,overwrite,win,fail) {
 if(overwrite==false) overwrite="false";
 else overwrite="true";
 PhoneGap.exec(win, fail, "Downloader", "downloadFile", [fileUrl,dirName,fileName,overwrite]);

};

PhoneGap.addConstructor(function() {
 PhoneGap.addPlugin("downloader", new Downloader());
 PluginManager.addService("Downloader","com.example.pgplugins.downloaderPlugin.Downloader");
});

For use it you have only to include the js file in the page and call it in this way

<script type="text/javascript" charset="utf-8" src="downloader.js"></script>
 <script type="text/javascript">

 window.plugins.downloader.downloadFile("http://www.toforge.com/archive.zip","sdcard/cache/","archive.zip", false,
 function(data){
 if(data=="exist"){
 alert("File already exist");
 }
 else{
 alert("File saved on sd card")
 }
 },function(data){ alert("error: "+data); });

 </script>

If you like it please jut say me “thanks” or send me 100000 € .
See you on the next post

If your using Celery for your back-office tasks will be very nice to run some tasks after an action performed on the front end of your web site, like an user action.
If your web front end is wrote in PHP there is an easy and useful way for do it trough Rabbit MQ, the message broker used by celery.
What we can do is simply put a message, that Celery workers can consume, in Rabbit MQ trough a pure AMQ PHP library called AMQPHP .
You can download this implementation of the AMQ 0.9.1 protocol from the gitHub project’s page.

Follow the instruction for generate the code in the readme file and simply include it in your project.

When you are sure that the library works and is able to publish message on Rabbit MQ you can use the class provided at the end on this post for put message on the broker ready for be consumed from celery workers.
This class offer a method called runCeleryTask($task,$arguments) that allow you to run a specific registered task with N arguments.
If I have a celery registered task called package.exampleTask.dojob that accept a string and an Integer I can schedule it in this way

$taskRunner = new TaskRunner($ini_string);
$taskRunner->runCeleryTask("package.exampleTask.dojob","string",1);

The $ini_string variable contains the configuration for the connection to the broker, a possible string of configuration looks like this

host=localhost
port=5672
username=testing
userpass=tock
vhost=mauro
exchange=celery
exchangeType=direct
queueName=celery

Here is the class that do the “Dirty Job” is quite easy and simple, I hope that this could help someone.
You don’t need to declare exchange and queue again, this are supposed to be already declared by celery.

<?php

use amqp_091 as amqp;
use amqp_091\protocol;
use amqp_091\wire;

include "amqphp/amqp.php";

class TaskRunner {
/** Instance of amqp\Connection */
private  $conn;
/** Instance of amqp\Channel */
private  $chan;
/** Name of  exchange */
private  $exchange;
/** Type of  exchange */
private  $exchangeType;
/** Name of  queue */
private  $queueName;

function  __construct($ini_string){
$sParams = parse_ini_string($ini_string);
if (! $sParams) {
throw new Exception("Failed to find broker settings", 9854);
}
$this->exchange = $sParams['exchange'];
$this->queueName = $sParams['queueName'];
$this->exchangeType = $sParams['exchangeType'];

$this->conn = new amqp\Connection($sParams);
}

private function openConnection(){
if ($this->conn) $this->conn->connect();
}

private function closeConnection () {
if ($this->conn) $this->conn->shutdown();
}

function runCeleryTask($task,$arguments){
if (!is_array($arguments)){
throw new Exception("The second parameter of the function runTask() must be an array");
}

$this->openConnection();
$chan = $this->conn->getChannel();

//Publish the message
$basicP = $chan->basic('publish', array('content-type' => 'application/json',
'content-encoding' => 'UTF-8',
'routing-key' => 'celery',
'mandatory' => false,
'immediate' => false,
'exchange' => $this->exchange));

$basicP->setContent('{"id":"'.uniqid('php_').'",
"task": "'.$task.'",
"args": ['.'"'.implode('","',$arguments).'"'.'],
"kwargs": {}}');

$chan->invoke($basicP);

$this->closeConnection();
}

}

?>

Ptwix è un componente da me creato per visualizzare la timeline del tuo account twitter direttamente sul tuo sito.
E’ scritto in PHP ed usa AJAX per effettuare un update asincrono quando viene richiesto.

Usa anche un sistema di cache XML per evitare che si superino le 100 richieste in un ora, limite imposto da twitter per evitare il sovraccarico dei server.

Ne potete vedere una demo qui http://ptwix.toforge.com?p=demo

Scrivo questa guida all’installazione in italiano qui sul mio blog  in quanto il sito ufficiale ho deciso di lasciarlo solo in lingua inglese.

Bando alle ciance e partiamo!!!
Scaricate l’archivio che preferite all’indirizzo http://ptwix.toforge.com?p=download e posizionate la cartella ptwix ovunque volete sul vostro server.
Poniamo l’attenzione sulla cartella cache all’interno del package ptwix, questa è la cartella di default per contenere i file di cache, e naturalmente deve avere i permessi di scrittura.

Non dovete per forza usare questa cartella ma una qualsiasi sul vostro server e in qualsiasi posizione.
Ora aprite il file ptwix_reader.php che si trova nella cartella as e modificate le seguenti righe

$username="yourtwitterusername";
$password="yourtwitterpassword";
$url_path="http://www.mysite.com/ptwix/";
$cache_folder="/var/www/examplesite/ptwix/cache/";

I primi due parametri sono le credenziali di autenticazione del vostro account twitter, l’url path e la path url assoluta che punta alla cartella di installazione di ptwix e infine cache_folder rappresenta  la posizione della cartella in cui saranno scritti i file di cache che, come vi dicevo prima, dovranno avere i permessi di scrittura.

Fatto questo possiamo andare ad inserire ptwix nella pagina che desideriamo con i seguenti passi

Includiamo il file ptwix.php della cartella core

<? include "ptwix/core/PtwiX.php" ?>

Creiamo una nuova istanza dell’ogetto passandogli nell’ordine i seguenti parametri

Instance Name: Il mome dell’istanza dell’ogetto, a vostro piacere.
Username: L’username del tuo account twitter
Password: La password del tuo account twitter
Url path: La path url della cartella di installazione di ptwix  (http://www.mysite.com/ptwix/)
Cache folder path: La path assoluta della cartella di cache
Timeline type: (Optional) La timeline da visualizzare  (user timeline o friends timeline). Default friends timeline
Theme: (Optional) Il nome del tema da utilizzare, default gray-blue

Dopo di che bisogna inserire il foglio di stile relativo al tema, potete farlo manualmente oppure utilizzando il metodo printCss_Ref.
Ora resta da  stampare il box di ptwix ovunque vogliamo utilizzando il metodo printBox.

Per chiarirvi le idee ecco un bell’esempio completo

<? include "core/PtwiX.php";
$PtwiX=new PtwiX('second','user','pass','http://www.mysite.com/ptwix/','/var/www/ptwix/cache/',PtwiX::$FRIENDS_TIMELINE,'silver-red');
?>
<html>
<head>
<? $PtwiX->printCssRef(); ?>
</head›
<body›
<? $PtwiX->printBox(); ?>
</body>
</html>

Per completezza vi ricordo l’esistenza del metodo setDimension(larghezza,altezza) che chiamato sull’oggetto vi permette di impostare la dimensione a vostro piacimento.
Inoltre per chi ha un dominio in hosting e gli risulta impossibile installare curl e il relativo modulo PHP esiste anche un metodo disableCurl(boolean) che permette di disabilitare l’uso di curl, ma in questo caso potrete visualizzare solo la  timeline  del vostro utente  e non quella dei vostri amici.

Se avete particolari domande o problemi commentate pure e non dimenticate di seguire me e ptwix su twitter.