svn commit: r1074398 - /hbase/trunk/src/examples/thrift/DemoClient.pl

[st...@apache.org]

Author: stack
Date: Fri Feb 25 04:31:04 2011
New Revision: 1074398

URL: http://svn.apache.org/viewvc?rev=1074398&view=rev
Log:
HBASE-3564 DemoClient.pl - a demo client in Perl

Added:
    hbase/trunk/src/examples/thrift/DemoClient.pl

Added: hbase/trunk/src/examples/thrift/DemoClient.pl
URL: http://svn.apache.org/viewvc/hbase/trunk/src/examples/thrift/DemoClient.pl?rev=1074398&view=auto
==============================================================================
--- hbase/trunk/src/examples/thrift/DemoClient.pl (added)
+++ hbase/trunk/src/examples/thrift/DemoClient.pl Fri Feb 25 04:31:04 2011
@@ -0,0 +1,294 @@
+#!/usr/bin/perl
+#   Copyright 2011 The Apache Software Foundation
+#  
+#   Licensed to the Apache Software Foundation (ASF) under one
+#   or more contributor license agreements.  See the NOTICE file
+#   distributed with this work for additional information
+#   regarding copyright ownership.  The ASF licenses this file
+#   to you under the Apache License, Version 2.0 (the
+#   "License"); you may not use this file except in compliance
+#   with the License.  You may obtain a copy of the License at
+#  
+#      http://www.apache.org/licenses/LICENSE-2.0
+# 
+#   Unless required by applicable law or agreed to in writing, software
+#   distributed under the License is distributed on an "AS IS" BASIS,
+#   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#   See the License for the specific language governing permissions and
+#   limitations under the License.
+#
+#
+
+# Instructions:
+# 1. Run Thrift to generate the perl module HBase
+#    thrift --gen perl ../../../src/java/org/apache/hadoop/hbase/thrift/Hbase.thrift 
+# 2. Add the gen-perl/Hbase directory to your perl's @INC path:
+#    a. This is one of the paths listed in: perl -e 'print join ("\n", @INC) . "\n"'
+#    -OR-
+#    b. set PERL5LIB to include the gen-perl/ directory
+# 3. Execute perl DemoClient.pl.
+
+use strict;
+use warnings;
+
+use Thrift::Socket;
+use Thrift::BufferedTransport;
+use Thrift::BinaryProtocol;
+use Hbase::Hbase;
+use Data::Dumper;
+
+sub printRow($)
+{
+	my $rowresult = shift;
+
+	return if (!$rowresult || @{$rowresult} < 1);
+	# rowresult is presummed to be a Hbase::TRowResult object
+
+	printf ("row: {%s}, cols: \n", $rowresult->[0]->{row});
+	my $values = $rowresult->[0]->{columns};
+	foreach my $key ( sort ( keys %{$values} ) )
+	{
+		printf ("{%s} => {%s}\n", $key, $values->{$key}->{value});
+	}
+}
+
+my $host = $ARGV[0] || "localhost";
+my $port = $ARGV[1] || 9090;
+
+my $socket = Thrift::Socket->new ($host, $port);
+$socket->setSendTimeout (10000);		# Ten seconds (value is in millisec)
+$socket->setRecvTimeout (20000);		# Twenty seconds (value is in millisec)
+
+my $transport = Thrift::BufferedTransport->new ($socket);
+my $protocol = Thrift::BinaryProtocol->new ($transport);
+my $client = Hbase::HbaseClient->new ($protocol);
+
+eval {
+	$transport->open ();
+};
+if ($@)
+{
+	print "Unable to connect: $@->{message}\n";
+	exit 1;
+}
+
+my $demo_table = "demo_table";
+
+print "scanning tables...\n";
+
+#
+# Search for all the tables in the HBase DB, return value is an arrayref
+#
+my $tables = $client->getTableNames();
+foreach my $table (sort @{$tables})
+{
+	print "  found {$table}\n";
+	# This client will re-create the $demo_table, so we need to drop it first
+	if ($table eq $demo_table)
+	{
+		# Before we can drop a table, it has to be disabled first
+		if ($client->isTableEnabled ($table))
+		{
+			print "    disabling table: {$table}\n";
+			$client->disableTable ($table);
+		}
+		# We assume the table has been disabled at this point
+		print "    deleting table: {$table}\n";
+		$client->deleteTable ($table);
+	}
+}
+
+#
+# Create the demo table with two column families, entry: and unused:
+#
+my $columns = [
+	Hbase::ColumnDescriptor->new ( { name => "entry:", maxVersions => 10 } ),
+	Hbase::ColumnDescriptor->new ( { name => "unused:" } ),
+	];
+
+print "creating table: {$demo_table}\n";
+eval {
+	# This can throw Hbase::IllegalArgument (HASH)
+	$client->createTable ( $demo_table, $columns );
+};
+if ($@)
+{
+	die "ERROR: Unable to create table {$demo_table}: $@->{message}\n";
+}
+
+print "column families in {$demo_table}:\n";
+my $descriptors = $client->getColumnDescriptors ($demo_table);
+foreach my $col (sort keys %{$descriptors})
+{
+	printf ("  column: {%s}, maxVer: {%s}\n", $descriptors->{$col}->{name}, $descriptors->{$col}->{maxVersions} );
+}
+
+#
+# Test UTF-8 handling
+#
+my $invalid = "foo-\xfc\xa1\xa1\xa1\xa1\xa1";
+my $valid = "foo-\xE7\x94\x9F\xE3\x83\x93\xE3\x83\xBC\xE3\x83\xAB";
+
+# non-utf8 is fine for data
+my $key = "foo";
+my $mutations = [ Hbase::Mutation->new ( { column => "entry:$key", value => $invalid } ) ];
+$client->mutateRow ( $demo_table, $key, $mutations );
+
+# try emptry strings
+$key = "";
+$mutations = [ Hbase::Mutation->new ( { column => "entry:$key", value => "" } ) ];
+$client->mutateRow ( $demo_table, $key, $mutations );
+
+# this row name is valid utf8
+$key = "foo";
+# $mutations = [ Hbase::Mutation->new ( column => "entry:$key", value => $valid ) ];
+# This is another way to use the Mutation class
+my $mutation = Hbase::Mutation->new ();
+$mutation->{column} = "entry:$key";
+$mutation->{value} = $valid;
+$mutations = [ $mutation ];
+$client->mutateRow ( $demo_table, $key, $mutations );
+
+# non-utf8 is not allowed in row names
+eval {
+	$mutations = [ Hbase::Mutation->new ( column => "entry:$key", value => $invalid ) ];
+	# this can throw a TApplicationException (HASH) error
+	$client->mutateRow ($demo_table, $key, $mutations);
+	die ("shouldn't get here!");
+};
+if ($@)
+{
+	print "expected error: $@->{message}\n";
+}
+
+#
+# Run a scanner on the rows we just created
+#
+print "Starting scanner...\n";
+$key = "";
+# scannerOpen expects ( table, key, <column descriptors> )
+# if key is empty, it searches for all entries in the table
+# if column descriptors is empty, it searches for all column descriptors within the table
+my $scanner = $client->scannerOpen ( $demo_table, $key, [ "entry:" ] );
+eval {
+
+	# scannerGet returns an empty arrayref (instead of an undef) to indicate no results
+	my $result = $client->scannerGet ( $scanner );
+	while ( $result && @{$result} > 0 )
+	{
+		printRow ( $result );
+		$result = $client->scannerGet ( $scanner );
+	}
+
+	$client->scannerClose ( $scanner );
+	print "Scanner finished\n";
+};
+if ($@)
+{
+	$client->scannerClose ( $scanner );
+	print "Scanner finished\n";
+}
+
+#
+# Run some operations on a bunch of rows
+#
+for (my $e = 100; $e > 0; $e--)
+{
+	# format row keys as "00000" to "00100";
+	my $row = sprintf ("%05d", $e);
+
+	$mutations = [ Hbase::Mutation->new ( { column => "unused:", value => "DELETE_ME" } ) ];
+	$client->mutateRow ( $demo_table, $row, $mutations );
+	printRow ( $client->getRow ( $demo_table, $row ) );
+	$client->deleteAllRow ( $demo_table, $row );
+
+	$mutations = [
+		Hbase::Mutation->new ( { column => "entry:num", value => "0" } ),
+		Hbase::Mutation->new ( { column => "entry:foo", value => "FOO" } ),
+		];	
+	$client->mutateRow ( $demo_table, $row, $mutations );
+	printRow ( $client->getRow ( $demo_table, $row ) );
+
+	$mutations = [
+		Hbase::Mutation->new ( { column => "entry:foo", isDelete => 1 } ),
+		Hbase::Mutation->new ( { column => "entry:num", value => -1 } ),
+		];	
+	$client->mutateRow ( $demo_table, $row, $mutations );
+	printRow ( $client->getRow ( $demo_table, $row ) );
+
+	$mutations = [
+		Hbase::Mutation->new ( { column => "entry:num", value => $e } ),
+		Hbase::Mutation->new ( { column => "entry:sqr", value => $e * $e } ),
+		];
+	$client->mutateRow ( $demo_table, $row, $mutations );
+	printRow ( $client->getRow ( $demo_table, $row ) );
+
+	$mutations = [ 
+		Hbase::Mutation->new ( { column => "entry:num", value => -999 } ),
+		Hbase::Mutation->new ( { column => "entry:sqr", isDelete => 1 } ),
+		];
+
+	# mutateRowTs => modify the row entry at the specified timestamp (ts)
+	$client->mutateRowTs ( $demo_table, $row, $mutations, 1 ); # shouldn't override latest
+	printRow ( $client->getRow ( $demo_table, $row ) );
+
+	my $versions = $client->getVer ( $demo_table, $row, "entry:num", 10 );
+	printf ( "row: {%s}, values: \n", $row );
+	foreach my $v ( @{$versions} )
+	{
+		printf ( "  {%s} @ {%s}\n", $v->{value}, $v->{timestamp} );
+	}
+
+	eval {
+
+		my $result = $client->get ( $demo_table, $row, "entry:foo" );
+
+		# Unfortunately, the API returns an empty arrayref instead of undef
+		# to signify a "not found", which makes it slightly inconvenient.
+		die "shouldn't get here!" if ($result && @{$result} > 0);
+
+		if (!$result || ($result && @{$result} < 1))
+		{
+			print "expected: {$row} not found in {$demo_table}\n";
+		}
+	};
+	if ($@)
+	{
+		print "expected error: $@\n";
+	}
+}
+
+my $column_descriptor = $client->getColumnDescriptors ( $demo_table );
+$columns = [];
+foreach my $col ( keys %{$column_descriptor} )
+{
+	my $colname = $column_descriptor->{$col}->{name};
+	print "column with name: {$colname}\n";
+	push ( @{$columns}, $colname);
+}
+
+print "Starting scanner...\n";
+$scanner = $client->scannerOpenWithStop ( $demo_table, "00020", "00040", $columns );
+eval {
+
+	# scannerGet returns an empty arrayref (instead of an undef) to indicate no results
+	my $result = $client->scannerGet ( $scanner );
+	while ( $result && @$result > 0 )
+	{
+		printRow ( $result );
+		$result = $client->scannerGet ( $scanner );
+	}
+
+	$client->scannerClose ( $scanner );
+	print "Scanner finished\n";
+};
+if ($@)
+{
+	$client->scannerClose ( $scanner );
+	print "Scanner finished\n";
+}
+
+$transport->close ();
+
+exit 0;
+