~yolanda.robla/charms/precise/gearman-server/trunk

Testing

-------

Simple test

 

ssh into one ( or each ) of your workers and type the following:

 

    gearman -h <gearman-job-server-fqdn> -w -f wc -- wc -l

 

ssh into any other instance/machine that has access to the gearman-job-server and type:

 

    gearman -h <gearman-job-server-fqdn> -f wc < /etc/passwd

 

        This should send a request for the number of lines in /etc/passwd to the gearman-job-server who will in turn ask the worker. The worker will pass the answer back through the job-server to the client. If it returns a number, it works.

 

Simple PHP test

 

Consider the following php test. Ssh into one ( or each ) of your workers and enter the following php code:

 

<?php

 

echo "Starting\n";

 

# Create our worker object.

$gmworker= new GearmanWorker();

 

# Add job server (gearman-job-server).

$gmworker->addServer("gearman-job-server");

 

# Register function "reverse" with the server. Change the worker function to

# "reverse_fn_fast" for a faster worker with no output.

$gmworker->addFunction("reverse", "reverse_fn");

 

print "Waiting for job...\n";

while($gmworker->work())

{

  if ($gmworker->returnCode() != GEARMAN_SUCCESS)

  {

    echo "return_code: " . $gmworker->returnCode() . "\n";

    break;

  }

}

 

function reverse_fn($job)

{

  echo "Received job: " . $job->handle() . "\n";

 

  $workload = $job->workload();

  $workload_size = $job->workloadSize();

 

  echo "Workload: $workload ($workload_size)\n";

 

  # This status loop is not needed, just showing how it works

  for ($x= 0; $x < $workload_size; $x++)

  {

    echo "Sending status: " . ($x + 1) . "/$workload_size complete\n";

    $job->sendStatus($x, $workload_size);

    sleep(1);

  }

 

  $result= strrev($workload);

  echo "Result: $result\n";

 

  # Return what we want to send back to the client.

  return $result;

}

 

# A much simpler and less verbose version of the above function would be:

function reverse_fn_fast($job)

{

  return strrev($job->workload());

}

 

?>

 

Save the above code somewhere in your worker instance. For the sake of this example, we'll save it on /tmp/reverse_worker.php. Run the following:

 

    php /tmp/reverse_worker.php

 

The above will connect to the gearman-job-server and wait for a job. This is a syncronous job.

 

From a machine with access to the gearman-job-server, run the following code:

 

<?php

 

# Create our client object.

$gmclient= new GearmanClient();

 

# Add job server (gearman-job-server).

$gmworker->addServer("gearman-job-server");

 

echo "Sending job\n";

 

# Send reverse job

do

{

  $result = $gmclient->do("reverse", "Hello!");

 

  # Check for various return packets and errors.

  switch($gmclient->returnCode())

  {

    case GEARMAN_WORK_DATA:

      echo "Data: $result\n";

      break;

    case GEARMAN_WORK_STATUS:

      list($numerator, $denominator)= $gmclient->doStatus();

      echo "Status: $numerator/$denominator complete\n";

      break;

    case GEARMAN_WORK_FAIL:

      echo "Failed\n";

      exit;

    case GEARMAN_SUCCESS:

      break;

    default:

      echo "RET: " . $gmclient->returnCode() . "\n";

      exit;

  }

}

while($gmclient->returnCode() != GEARMAN_SUCCESS);

 

?>

 

Save the above code as /tmp/reverse_client.php and run:

 

    php reverse_client.php

 

The above example will output something similar to:

 

php reverse_worker.php

Starting

Waiting for job...

Received job: H:gearman-job-server:36

Workload: Hello! (6)

Sending status: 1/6 complete

Sending status: 2/6 complete

Sending status: 3/6 complete

Sending status: 4/6 complete

Sending status: 5/6 complete

Sending status: 6/6 complete

Result: !olleH

 

php reverse_client.php

Starting

Sending job

Status: 1/6 complete

Status: 2/6 complete

Status: 3/6 complete

Status: 4/6 complete

Status: 5/6 complete

Status: 6/6 complete

Success: !olleH

 

A simple Python test

 

On a worker ( or all of them ) save the following file as /tmp/reverse_worker.py:

 

gm_worker = gearman.GearmanWorker(['localhost:4730'])

 

# See gearman/job.py to see attributes on the GearmanJob

# Send back a reversed version of the 'data' string

def task_listener_reverse(gearman_worker, gearman_job):

    return reversed(gearman_job.data)

 

# gm_worker.set_client_id is optional

gm_worker.set_client_id('your_worker_client_id_name')

gm_worker.register_task('reverse', task_listener_reverse)

 

# Enter our work loop and call gm_worker.after_poll() after each time we timeout/see socket activity

gm_worker.work()

 

Run the above code:

 

python /tmp/reverse_worker.py

 

On a client machine save the following code as /tmp/reverse_client.py:

 

def check_request_status(job_request):

    if job_request.complete:

        print "Job %s finished!  Result: %s - %s" % (job_request.job.unique, job_request.state, job_request.result)

    elif job_request.timed_out:

        print "Job %s timed out!" % job_request.unique

    elif job_request.state == JOB_UNKNOWN:

        print "Job %s connection failed!" % job_request.unique

 

gm_client = gearman.GearmanClient(['localhost:4730', 'otherhost:4730'])

 

# See gearman/job.py to see attributes on the GearmanJobRequest

# Defaults to PRIORITY_NONE, background=False (synchronous task), wait_until_complete=True

completed_job_request = gm_client.submit_job("task_name", "arbitrary binary data")

check_request_status(completed_job_request)

 

 

Run the above code:

 

python /tmp/reverse_client.py