hbase-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From a...@apache.org
Subject [1/2] hbase git commit: Revert HBASE-15965 and HBASE-15849. While it's fine to introduce these format changes in minor version, reverting it from branch-1 after discussion on HBASE-16044.
Date Wed, 29 Jun 2016 01:00:02 GMT
Repository: hbase
Updated Branches:
  refs/heads/branch-1 7a78d871d -> 48492ec7f


http://git-wip-us.apache.org/repos/asf/hbase/blob/48492ec7/hbase-shell/src/main/ruby/shell/commands/update_peer_config.rb
----------------------------------------------------------------------
diff --git a/hbase-shell/src/main/ruby/shell/commands/update_peer_config.rb b/hbase-shell/src/main/ruby/shell/commands/update_peer_config.rb
index e6f1c9e..bcecb91 100644
--- a/hbase-shell/src/main/ruby/shell/commands/update_peer_config.rb
+++ b/hbase-shell/src/main/ruby/shell/commands/update_peer_config.rb
@@ -40,7 +40,9 @@ To update TABLE_CFs, see the append_peer_tableCFs and remove_peer_tableCFs
comma
       end
 
       def command(id, args = {})
-        replication_admin.update_peer_config(id, args)
+        format_simple_command do
+          replication_admin.update_peer_config(id, args)
+        end
       end
     end
   end

http://git-wip-us.apache.org/repos/asf/hbase/blob/48492ec7/hbase-shell/src/main/ruby/shell/commands/user_permission.rb
----------------------------------------------------------------------
diff --git a/hbase-shell/src/main/ruby/shell/commands/user_permission.rb b/hbase-shell/src/main/ruby/shell/commands/user_permission.rb
index 4b5d3ff..71b98f3 100644
--- a/hbase-shell/src/main/ruby/shell/commands/user_permission.rb
+++ b/hbase-shell/src/main/ruby/shell/commands/user_permission.rb
@@ -40,14 +40,16 @@ EOF
       end
 
       def command(table_regex=nil)
+        #format_simple_command do
         #admin.user_permission(table_regex)
+        now = Time.now
         formatter.header(["User", "Namespace,Table,Family,Qualifier:Permission"])
 
         count = security_admin.user_permission(table_regex) do |user, permission|
           formatter.row([ user, permission])
         end
 
-        formatter.footer(count)
+        formatter.footer(now, count)
       end
     end
   end

http://git-wip-us.apache.org/repos/asf/hbase/blob/48492ec7/hbase-shell/src/main/ruby/shell/commands/wal_roll.rb
----------------------------------------------------------------------
diff --git a/hbase-shell/src/main/ruby/shell/commands/wal_roll.rb b/hbase-shell/src/main/ruby/shell/commands/wal_roll.rb
index a94e9e1..0fe1870 100644
--- a/hbase-shell/src/main/ruby/shell/commands/wal_roll.rb
+++ b/hbase-shell/src/main/ruby/shell/commands/wal_roll.rb
@@ -30,10 +30,11 @@ EOF
       end
 
       def command(server_name)
-        admin.wal_roll(server_name)
+        format_simple_command do
+          admin.wal_roll(server_name)
+        end
       end
     end
-
     #TODO remove old HLog version
     class HlogRoll < WalRoll
     end

http://git-wip-us.apache.org/repos/asf/hbase/blob/48492ec7/hbase-shell/src/main/ruby/shell/formatter.rb
----------------------------------------------------------------------
diff --git a/hbase-shell/src/main/ruby/shell/formatter.rb b/hbase-shell/src/main/ruby/shell/formatter.rb
index 2f800f6..6e598fb 100644
--- a/hbase-shell/src/main/ruby/shell/formatter.rb
+++ b/hbase-shell/src/main/ruby/shell/formatter.rb
@@ -64,7 +64,7 @@ module Shell
 
         # Print a string
         if args.is_a?(String)
-          output_str(args)
+          output(args)
           @out.puts
           return
         end
@@ -162,7 +162,7 @@ module Shell
         return str
       end
 
-      def output_str(str)
+      def output(str)
         output(@max_width, str)
       end
 
@@ -177,12 +177,15 @@ module Shell
         end
       end
 
-      def footer(row_count = nil, is_stale = false)
+      def footer(start_time = nil, row_count = nil, is_stale = false)
+        return unless start_time
         row_count ||= @row_count
         # Only output elapsed time and row count if startTime passed
-        @out.puts("%d row(s)" % [row_count])
+        @out.print("%d row(s) in %.4f seconds" % [row_count, Time.now - start_time])
         if is_stale == true
           @out.puts(" (possible stale results) ")
+        else
+          @out.puts("")
         end
       end
     end

http://git-wip-us.apache.org/repos/asf/hbase/blob/48492ec7/hbase-shell/src/test/java/org/apache/hadoop/hbase/client/TestReplicationShell.java
----------------------------------------------------------------------
diff --git a/hbase-shell/src/test/java/org/apache/hadoop/hbase/client/TestReplicationShell.java
b/hbase-shell/src/test/java/org/apache/hadoop/hbase/client/TestReplicationShell.java
index 04fbc7a..3f4af05 100644
--- a/hbase-shell/src/test/java/org/apache/hadoop/hbase/client/TestReplicationShell.java
+++ b/hbase-shell/src/test/java/org/apache/hadoop/hbase/client/TestReplicationShell.java
@@ -28,7 +28,7 @@ import org.junit.experimental.categories.Category;
 
 @Category({ ClientTests.class, LargeTests.class })
 public class TestReplicationShell extends AbstractTestShell {
-  @Test
+  @Ignore ("Disabled because hangs on occasion.. about 10% of the time") @Test
   public void testRunShellTests() throws IOException {
     System.setProperty("shell.test.include", "replication_admin_test.rb");
     // Start all ruby tests

http://git-wip-us.apache.org/repos/asf/hbase/blob/48492ec7/hbase-shell/src/test/ruby/hbase/admin_test.rb
----------------------------------------------------------------------
diff --git a/hbase-shell/src/test/ruby/hbase/admin_test.rb b/hbase-shell/src/test/ruby/hbase/admin_test.rb
index a7d9686..4a70b56 100644
--- a/hbase-shell/src/test/ruby/hbase/admin_test.rb
+++ b/hbase-shell/src/test/ruby/hbase/admin_test.rb
@@ -41,21 +41,21 @@ module Hbase
     end
 
     define_test "exists? should return true when a table exists" do
-      assert(command(:exists, 'hbase:meta'))
+      assert(admin.exists?('hbase:meta'))
     end
 
     define_test "exists? should return false when a table exists" do
-      assert(!command(:exists, 'NOT.EXISTS'))
+      assert(!admin.exists?('NOT.EXISTS'))
     end
 
     define_test "enabled? should return true for enabled tables" do
-      command(:enable, @test_name)
-      assert(command(:is_enabled, @test_name))
+      admin.enable(@test_name)
+      assert(admin.enabled?(@test_name))
     end
 
     define_test "enabled? should return false for disabled tables" do
-      command(:disable, @test_name)
-      assert(!command(:is_enabled, @test_name))
+      admin.disable(@test_name)
+      assert(!admin.enabled?(@test_name))
     end
   end
 
@@ -78,67 +78,63 @@ module Hbase
     end
 
     define_test "list should return a list of tables" do
-      list = command(:list)
-      assert(list.member?(@test_name))
+      assert(admin.list.member?(@test_name))
     end
 
     define_test "list should not return meta tables" do
-      list = command(:list)
-      assert(!list.member?('hbase:meta'))
+      assert(!admin.list.member?('hbase:meta'))
     end
 
     define_test "list_namespace_tables for the system namespace should return a list of tables"
do
-      list = command(:list_namespace_tables, 'hbase')
-      assert(list.count > 0)
+      assert(admin.list_namespace_tables('hbase').count > 0)
     end
 
     define_test "list_namespace_tables for the default namespace should return a list of
tables" do
-      list = command(:list_namespace_tables, 'default')
-      assert(list.count > 0)
+      assert(admin.list_namespace_tables('default').count > 0)
     end
 
     #-------------------------------------------------------------------------------
 
     define_test "flush should work" do
-      command(:flush, 'hbase:meta')
+      admin.flush('hbase:meta')
     end
 
     #-------------------------------------------------------------------------------
 
     define_test "compact should work" do
-      command(:compact, 'hbase:meta')
+      admin.compact('hbase:meta')
     end
 
     #-------------------------------------------------------------------------------
 
     define_test "major_compact should work" do
-      command(:major_compact, 'hbase:meta')
+      admin.major_compact('hbase:meta')
     end
 
     #-------------------------------------------------------------------------------
 
     define_test "split should work" do
-      command(:split, 'hbase:meta', nil)
+      admin.split('hbase:meta', nil)
     end
 
     #-------------------------------------------------------------------------------
 
     define_test "drop should fail on non-existent tables" do
       assert_raise(ArgumentError) do
-        command(:drop, 'NOT.EXISTS')
+        admin.drop('NOT.EXISTS')
       end
     end
 
     define_test "drop should fail on enabled tables" do
       assert_raise(ArgumentError) do
-        command(:drop, @test_name)
+        admin.drop(@test_name)
       end
     end
 
     define_test "drop should drop tables" do
-      command(:disable, @test_name)
-      command(:drop, @test_name)
-      assert(!command(:exists, @test_name))
+      admin.disable(@test_name)
+      admin.drop(@test_name)
+      assert(!admin.exists?(@test_name))
     end
 
     #-------------------------------------------------------------------------------
@@ -151,46 +147,45 @@ module Hbase
 
     define_test "create should fail with non-string table names" do
       assert_raise(ArgumentError) do
-        command(:create, 123, 'xxx')
+        admin.create(123, 'xxx')
       end
     end
 
     define_test "create should fail with non-string/non-hash column args" do
       assert_raise(ArgumentError) do
-        command(:create, @create_test_name, 123)
+        admin.create(@create_test_name, 123)
       end
     end
 
     define_test "create should fail without columns" do
       drop_test_table(@create_test_name)
       assert_raise(ArgumentError) do
-        command(:create, @create_test_name)
+        admin.create(@create_test_name)
       end
     end
     
     define_test "create should fail without columns when called with options" do
       drop_test_table(@create_test_name)
       assert_raise(ArgumentError) do
-        command(:create, @create_test_name, { OWNER => 'a' })
+        admin.create(@create_test_name, { OWNER => 'a' })
       end
     end
 
     define_test "create should work with string column args" do
       drop_test_table(@create_test_name)
-      command(:create, @create_test_name, 'a', 'b')
+      admin.create(@create_test_name, 'a', 'b')
       assert_equal(['a:', 'b:'], table(@create_test_name).get_all_columns.sort)
      end
 
     define_test "create should work with hash column args" do
       drop_test_table(@create_test_name)
-      command(:create, @create_test_name, { NAME => 'a'}, { NAME => 'b'})
+      admin.create(@create_test_name, { NAME => 'a'}, { NAME => 'b'})
       assert_equal(['a:', 'b:'], table(@create_test_name).get_all_columns.sort)
     end
     
     define_test "create should be able to set table options" do
       drop_test_table(@create_test_name)
-      command(:create, @create_test_name, 'a', 'b', 'MAX_FILESIZE' => 12345678,
-              OWNER => '987654321')
+      admin.create(@create_test_name, 'a', 'b', 'MAX_FILESIZE' => 12345678, OWNER =>
'987654321')
       assert_equal(['a:', 'b:'], table(@create_test_name).get_all_columns.sort)
       assert_match(/12345678/, admin.describe(@create_test_name))
       assert_match(/987654321/, admin.describe(@create_test_name))
@@ -198,15 +193,14 @@ module Hbase
         
     define_test "create should ignore table_att" do
       drop_test_table(@create_test_name)
-      command(:create, @create_test_name, 'a', 'b', METHOD => 'table_att', OWNER =>
'987654321')
+      admin.create(@create_test_name, 'a', 'b', METHOD => 'table_att', OWNER => '987654321')
       assert_equal(['a:', 'b:'], table(@create_test_name).get_all_columns.sort)
       assert_match(/987654321/, admin.describe(@create_test_name))
     end
     
     define_test "create should work with SPLITALGO" do
       drop_test_table(@create_test_name)
-      command(:create, @create_test_name, 'a', 'b',
-              {NUMREGIONS => 10, SPLITALGO => 'HexStringSplit'})
+      admin.create(@create_test_name, 'a', 'b', {NUMREGIONS => 10, SPLITALGO => 'HexStringSplit'})
       assert_equal(['a:', 'b:'], table(@create_test_name).get_all_columns.sort)
     end
 
@@ -229,13 +223,17 @@ module Hbase
       table(@test_name).put(2, "x:a", 2)
       assert_equal(2, table(@test_name)._count_internal)
       # This is hacky.  Need to get the configuration into admin instance
-      command(:truncate, @test_name)
+      admin.truncate(@test_name, $TEST_CLUSTER.getConfiguration)
       assert_equal(0, table(@test_name)._count_internal)
     end
 
     define_test "truncate should yield log records" do
-      output = capture_stdout { command(:truncate, @test_name) }
-      assert(!output.empty?)
+      logs = []
+      admin.truncate(@test_name, $TEST_CLUSTER.getConfiguration) do |log|
+        assert_kind_of(String, log)
+        logs << log
+      end
+      assert(!logs.empty?)
     end
   end
 
@@ -259,68 +257,77 @@ module Hbase
 
     define_test "alter should fail with non-string table names" do
       assert_raise(ArgumentError) do
-        command(:alter, 123, METHOD => 'delete', NAME => 'y')
+        admin.alter(123, true, METHOD => 'delete', NAME => 'y')
       end
     end
 
     define_test "alter should fail with non-existing tables" do
       assert_raise(ArgumentError) do
-        command(:alter, 'NOT.EXISTS', METHOD => 'delete', NAME => 'y')
+        admin.alter('NOT.EXISTS', true, METHOD => 'delete', NAME => 'y')
       end
     end
 
     define_test "alter should not fail with enabled tables" do
-      command(:enable, @test_name)
-      command(:alter, @test_name, METHOD => 'delete', NAME => 'y')
+      admin.enable(@test_name)
+      admin.alter(@test_name, true, METHOD => 'delete', NAME => 'y')
     end
 
     define_test "alter should be able to delete column families" do
       assert_equal(['x:', 'y:'], table(@test_name).get_all_columns.sort)
-      command(:alter, @test_name, METHOD => 'delete', NAME => 'y')
-      command(:enable, @test_name)
+      admin.alter(@test_name, true, METHOD => 'delete', NAME => 'y')
+      admin.enable(@test_name)
       assert_equal(['x:'], table(@test_name).get_all_columns.sort)
     end
 
     define_test "alter should be able to add column families" do
       assert_equal(['x:', 'y:'], table(@test_name).get_all_columns.sort)
-      command(:alter, @test_name, NAME => 'z')
-      command(:enable, @test_name)
+      admin.alter(@test_name, true, NAME => 'z')
+      admin.enable(@test_name)
       assert_equal(['x:', 'y:', 'z:'], table(@test_name).get_all_columns.sort)
     end
 
     define_test "alter should be able to add column families (name-only alter spec)" do
       assert_equal(['x:', 'y:'], table(@test_name).get_all_columns.sort)
-      command(:alter, @test_name, 'z')
-      command(:enable, @test_name)
+      admin.alter(@test_name, true, 'z')
+      admin.enable(@test_name)
       assert_equal(['x:', 'y:', 'z:'], table(@test_name).get_all_columns.sort)
     end
 
     define_test "alter should support more than one alteration in one call" do
       assert_equal(['x:', 'y:'], table(@test_name).get_all_columns.sort)
-      alterOutput = capture_stdout {
-        command(:alter, @test_name, { NAME => 'z' }, { METHOD => 'delete', NAME =>
'y' },
-                'MAX_FILESIZE' => 12345678) }
-      command(:enable, @test_name)
+      alterOutput = capture_stdout { admin.alter(@test_name, true, { NAME => 'z' },
+        { METHOD => 'delete', NAME => 'y' }, 'MAX_FILESIZE' => 12345678) }
+      admin.enable(@test_name)
       assert_equal(1, /Updating all regions/.match(alterOutput).size,
         "HBASE-15641 - Should only perform one table modification per alter.")
       assert_equal(['x:', 'z:'], table(@test_name).get_all_columns.sort)
       assert_match(/12345678/, admin.describe(@test_name))
     end
 
+    def capture_stdout
+      begin
+        old_stdout = $stdout
+        $stdout = StringIO.new('','w')
+        yield
+        $stdout.string
+      ensure
+        $stdout = old_stdout
+      end
+    end
 
     define_test 'alter should support shortcut DELETE alter specs' do
       assert_equal(['x:', 'y:'], table(@test_name).get_all_columns.sort)
-      command(:alter, @test_name, 'delete' => 'y')
+      admin.alter(@test_name, true, 'delete' => 'y')
       assert_equal(['x:'], table(@test_name).get_all_columns.sort)
     end
 
     define_test "alter should be able to change table options" do
-      command(:alter, @test_name, METHOD => 'table_att', 'MAX_FILESIZE' => 12345678)
+      admin.alter(@test_name, true, METHOD => 'table_att', 'MAX_FILESIZE' => 12345678)
       assert_match(/12345678/, admin.describe(@test_name))
     end
 
     define_test "alter should be able to change table options w/o table_att" do
-      command(:alter, @test_name, 'MAX_FILESIZE' => 12345678)
+      admin.alter(@test_name, true, 'MAX_FILESIZE' => 12345678)
       assert_match(/12345678/, admin.describe(@test_name))
     end
     
@@ -336,7 +343,7 @@ module Hbase
       # eval() is used to convert a string to regex
       assert_no_match(eval("/" + class_name + "/"), admin.describe(@test_name))
       assert_no_match(eval("/" + cp_key + "/"), admin.describe(@test_name))
-      command(:alter, @test_name, 'METHOD' => 'table_att', cp_key => cp_value)
+      admin.alter(@test_name, true, 'METHOD' => 'table_att', cp_key => cp_value)
       assert_match(eval("/" + class_name + "/"), admin.describe(@test_name))
       assert_match(eval("/" + cp_key + "\\$(\\d+)/"), admin.describe(@test_name))
     end
@@ -346,12 +353,12 @@ module Hbase
       create_test_table(@test_name)
 
       key = "MAX_FILESIZE"
-      command(:alter, @test_name, 'METHOD' => 'table_att', key => 12345678)
+      admin.alter(@test_name, true, 'METHOD' => 'table_att', key => 12345678)
 
       # eval() is used to convert a string to regex
       assert_match(eval("/" + key + "/"), admin.describe(@test_name))
 
-      command(:alter, @test_name, 'METHOD' => 'table_att_unset', 'NAME' => key)
+      admin.alter(@test_name, true, 'METHOD' => 'table_att_unset', 'NAME' => key)
       assert_no_match(eval("/" + key + "/"), admin.describe(@test_name))
     end
 
@@ -360,13 +367,13 @@ module Hbase
 
       key_1 = "TestAttr1"
       key_2 = "TestAttr2"
-      command(:create, @test_name, { NAME => 'i'}, METADATA => { key_1 => 1, key_2
=> 2 })
+      admin.create(@test_name, { NAME => 'i'}, METADATA => { key_1 => 1, key_2 =>
2 })
 
       # eval() is used to convert a string to regex
       assert_match(eval("/" + key_1 + "/"), admin.describe(@test_name))
       assert_match(eval("/" + key_2 + "/"), admin.describe(@test_name))
 
-      command(:alter, @test_name, 'METHOD' => 'table_att_unset', 'NAME' => [ key_1,
key_2 ])
+      admin.alter(@test_name, true, 'METHOD' => 'table_att_unset', 'NAME' => [ key_1,
key_2 ])
       assert_no_match(eval("/" + key_1 + "/"), admin.describe(@test_name))
       assert_no_match(eval("/" + key_2 + "/"), admin.describe(@test_name))
     end
@@ -414,66 +421,66 @@ module Hbase
     #-------------------------------------------------------------------------------
     define_test "Snapshot should fail with non-string snapshot name" do
       assert_raise(NoMethodError) do
-        command(:snapshot, @create_test_snapshot, 123)
+        admin.snapshot(123, 'xxx')
       end
     end
 
     define_test "Snapshot should fail with non-string table name" do
       assert_raise(NoMethodError) do
-        command(:snapshot, 123, 'xxx')
+        admin.snapshot(@create_test_snapshot, 123)
       end
     end
 
     define_test "Snapshot should fail without table name" do
       assert_raise(ArgumentError) do
-        command(:snapshot, "hbase_create_test_snapshot")
+        admin.snapshot("hbase_create_test_snapshot")
       end
     end
 
     define_test "Snapshot should work with string args" do
       drop_test_snapshot()
-      command(:snapshot, @test_name, @create_test_snapshot)
-      list = command(:list_snapshots, @create_test_snapshot)
+      admin.snapshot(@test_name, @create_test_snapshot)
+      list = admin.list_snapshot(@create_test_snapshot)
       assert_equal(1, list.size)
     end
 
     define_test "Snapshot should work when SKIP_FLUSH args" do
       drop_test_snapshot()
-      command(:snapshot, @test_name, @create_test_snapshot, {SKIP_FLUSH => true})
-      list = command(:list_snapshots, @create_test_snapshot)
+      admin.snapshot(@test_name, @create_test_snapshot, {SKIP_FLUSH => true})
+      list = admin.list_snapshot(@create_test_snapshot)
       assert_equal(1, list.size)
     end
 
     define_test "List snapshot without any args" do
       drop_test_snapshot()
-      command(:snapshot, @test_name, @create_test_snapshot)
-      list = command(:list_snapshots)
+      admin.snapshot(@test_name, @create_test_snapshot)
+      list = admin.list_snapshot()
       assert_equal(1, list.size)
     end
 
     define_test "List snapshot for a non-existing snapshot" do
-      list = command(:list_snapshots, "xyz")
+      list = admin.list_snapshot("xyz")
       assert_equal(0, list.size)
     end
 
     define_test "Restore snapshot without any args" do
       assert_raise(ArgumentError) do
-        command(:restore_snapshot)
+        admin.restore_snapshot()
       end
     end
 
     define_test "Restore snapshot should work" do
       drop_test_snapshot()
       restore_table = "test_restore_snapshot_table"
-      command(:create, restore_table, 'f1', 'f2')
+      admin.create(restore_table, 'f1', 'f2')
       assert_match(eval("/" + "f1" + "/"), admin.describe(restore_table))
       assert_match(eval("/" + "f2" + "/"), admin.describe(restore_table))
-      command(:snapshot, restore_table, @create_test_snapshot)
-      command(:alter, restore_table, METHOD => 'delete', NAME => 'f1')
+      admin.snapshot(restore_table, @create_test_snapshot)
+      admin.alter(restore_table, true, METHOD => 'delete', NAME => 'f1')
       assert_no_match(eval("/" + "f1" + "/"), admin.describe(restore_table))
       assert_match(eval("/" + "f2" + "/"), admin.describe(restore_table))
       drop_test_table(restore_table)
-      command(:restore_snapshot, @create_test_snapshot)
+      admin.restore_snapshot(@create_test_snapshot)
       assert_match(eval("/" + "f1" + "/"), admin.describe(restore_table))
       assert_match(eval("/" + "f2" + "/"), admin.describe(restore_table))
       drop_test_table(restore_table)
@@ -481,13 +488,13 @@ module Hbase
 
     define_test "Clone snapshot without any args" do
       assert_raise(ArgumentError) do
-        command(:restore_snapshot)
+        admin.restore_snapshot()
       end
     end
 
     define_test "Clone snapshot without table name args" do
       assert_raise(ArgumentError) do
-        command(:clone_snapshot, @create_test_snapshot)
+        admin.clone_snapshot(@create_test_snapshot)
       end
     end
 
@@ -496,8 +503,8 @@ module Hbase
       clone_table = "test_clone_snapshot_table"
       assert_match(eval("/" + "x" + "/"), admin.describe(@test_name))
       assert_match(eval("/" + "y" + "/"), admin.describe(@test_name))
-      command(:snapshot, @test_name, @create_test_snapshot)
-      command(:clone_snapshot, @create_test_snapshot, clone_table)
+      admin.snapshot(@test_name, @create_test_snapshot)
+      admin.clone_snapshot(@create_test_snapshot, clone_table)
       assert_match(eval("/" + "x" + "/"), admin.describe(clone_table))
       assert_match(eval("/" + "y" + "/"), admin.describe(clone_table))
       drop_test_table(clone_table)
@@ -511,11 +518,11 @@ module Hbase
 
     define_test "Delete snapshot should work" do
       drop_test_snapshot()
-      command(:snapshot, @test_name, @create_test_snapshot)
-      list = command(:list_snapshots)
+      admin.snapshot(@test_name, @create_test_snapshot)
+      list = admin.list_snapshot()
       assert_equal(1, list.size)
       admin.delete_snapshot(@create_test_snapshot)
-      list = command(:list_snapshots)
+      list = admin.list_snapshot()
       assert_equal(0, list.size)
     end
 
@@ -527,17 +534,17 @@ module Hbase
 
     define_test "Delete all snapshots should work" do
       drop_test_snapshot()
-      command(:snapshot, @test_name, "delete_all_snapshot1")
-      command(:snapshot, @test_name, "delete_all_snapshot2")
-      command(:snapshot, @test_name, "snapshot_delete_all_1")
-      command(:snapshot, @test_name, "snapshot_delete_all_2")
-      list = command(:list_snapshots)
+      admin.snapshot(@test_name, "delete_all_snapshot1")
+      admin.snapshot(@test_name, "delete_all_snapshot2")
+      admin.snapshot(@test_name, "snapshot_delete_all_1")
+      admin.snapshot(@test_name, "snapshot_delete_all_2")
+      list = admin.list_snapshot()
       assert_equal(4, list.size)
       admin.delete_all_snapshot("d.*")
-      list = command(:list_snapshots)
+      list = admin.list_snapshot()
       assert_equal(2, list.size)
       admin.delete_all_snapshot(".*")
-      list = command(:list_snapshots)
+      list = admin.list_snapshot()
       assert_equal(0, list.size)
     end
 
@@ -549,48 +556,48 @@ module Hbase
 
     define_test "Delete table snapshots should work" do
       drop_test_snapshot()
-      command(:snapshot, @test_name, "delete_table_snapshot1")
-      command(:snapshot, @test_name, "delete_table_snapshot2")
-      command(:snapshot, @test_name, "snapshot_delete_table1")
+      admin.snapshot(@test_name, "delete_table_snapshot1")
+      admin.snapshot(@test_name, "delete_table_snapshot2")
+      admin.snapshot(@test_name, "snapshot_delete_table1")
       new_table = "test_delete_table_snapshots_table"
-      command(:create, new_table, 'f1')
-      command(:snapshot, new_table, "delete_table_snapshot3")
-      list = command(:list_snapshots)
+      admin.create(new_table, 'f1')
+      admin.snapshot(new_table, "delete_table_snapshot3")
+      list = admin.list_snapshot()
       assert_equal(4, list.size)
       admin.delete_table_snapshots(@test_name, "d.*")
-      list = command(:list_snapshots)
+      list = admin.list_snapshot()
       assert_equal(2, list.size)
       admin.delete_table_snapshots(@test_name)
-      list = command(:list_snapshots)
+      list = admin.list_snapshot()
       assert_equal(1, list.size)
       admin.delete_table_snapshots(".*", "d.*")
-      list = command(:list_snapshots)
+      list = admin.list_snapshot()
       assert_equal(0, list.size)
       drop_test_table(new_table)
     end
 
     define_test "List table snapshots without any args" do
       assert_raise(ArgumentError) do
-        command(:list_table_snapshots)
+        admin.list_table_snapshots()
       end
     end
 
     define_test "List table snapshots should work" do
       drop_test_snapshot()
-      command(:snapshot, @test_name, "delete_table_snapshot1")
-      command(:snapshot, @test_name, "delete_table_snapshot2")
-      command(:snapshot, @test_name, "snapshot_delete_table1")
+      admin.snapshot(@test_name, "delete_table_snapshot1")
+      admin.snapshot(@test_name, "delete_table_snapshot2")
+      admin.snapshot(@test_name, "snapshot_delete_table1")
       new_table = "test_list_table_snapshots_table"
-      command(:create, new_table, 'f1')
-      command(:snapshot, new_table, "delete_table_snapshot3")
-      list = command(:list_table_snapshots, ".*")
+      admin.create(new_table, 'f1')
+      admin.snapshot(new_table, "delete_table_snapshot3")
+      list = admin.list_table_snapshots(".*")
       assert_equal(4, list.size)
-      list = command(:list_table_snapshots, @test_name, "d.*")
+      list = admin.list_table_snapshots(@test_name, "d.*")
       assert_equal(2, list.size)
-      list = command(:list_table_snapshots, @test_name)
+      list = admin.list_table_snapshots(@test_name)
       assert_equal(3, list.size)
       admin.delete_table_snapshots(".*")
-      list = command(:list_table_snapshots, ".*", ".*")
+      list = admin.list_table_snapshots(".*", ".*")
       assert_equal(0, list.size)
       drop_test_table(new_table)
     end

http://git-wip-us.apache.org/repos/asf/hbase/blob/48492ec7/hbase-shell/src/test/ruby/hbase/replication_admin_test.rb
----------------------------------------------------------------------
diff --git a/hbase-shell/src/test/ruby/hbase/replication_admin_test.rb b/hbase-shell/src/test/ruby/hbase/replication_admin_test.rb
index 33a6552..ac088ed 100644
--- a/hbase-shell/src/test/ruby/hbase/replication_admin_test.rb
+++ b/hbase-shell/src/test/ruby/hbase/replication_admin_test.rb
@@ -33,25 +33,25 @@ module Hbase
 
       setup_hbase
 
-      assert_equal(0, command(:list_peers).length)
+      assert_equal(0, replication_admin.list_peers.length)
     end
 
     def teardown
-      assert_equal(0, command(:list_peers).length)
+      assert_equal(0, replication_admin.list_peers.length)
 
       shutdown
     end
 
     define_test "add_peer: should fail when args isn't specified" do
       assert_raise(ArgumentError) do
-        command(:add_peer, @peer_id, nil)
+        replication_admin.add_peer(@peer_id, nil)
       end
     end
 
     define_test "add_peer: fail when neither CLUSTER_KEY nor ENDPOINT_CLASSNAME are specified"
do
       assert_raise(ArgumentError) do
         args = {}
-        command(:add_peer, @peer_id, args)
+        replication_admin.add_peer(@peer_id, args)
       end
     end
 
@@ -59,86 +59,86 @@ module Hbase
       assert_raise(ArgumentError) do
         args = { CLUSTER_KEY => 'zk1,zk2,zk3:2182:/hbase-prod',
                  ENDPOINT_CLASSNAME => 'org.apache.hadoop.hbase.MyReplicationEndpoint'
}
-        command(:add_peer, @peer_id, args)
+        replication_admin.add_peer(@peer_id, args)
       end
     end
 
     define_test "add_peer: args must be a string or number" do
       assert_raise(ArgumentError) do
-        command(:add_peer, @peer_id, 1)
+        replication_admin.add_peer(@peer_id, 1)
       end
       assert_raise(ArgumentError) do
-        command(:add_peer, @peer_id, ['test'])
+        replication_admin.add_peer(@peer_id, ['test'])
       end
     end
 
     define_test "add_peer: single zk cluster key" do
       cluster_key = "server1.cie.com:2181:/hbase"
 
-      command(:add_peer, @peer_id, cluster_key)
+      replication_admin.add_peer(@peer_id, cluster_key)
 
-      assert_equal(1, command(:list_peers).length)
-      assert(command(:list_peers).key?(@peer_id))
-      assert_equal(cluster_key, command(:list_peers).fetch(@peer_id))
+      assert_equal(1, replication_admin.list_peers.length)
+      assert(replication_admin.list_peers.key?(@peer_id))
+      assert_equal(cluster_key, replication_admin.list_peers.fetch(@peer_id))
 
       # cleanup for future tests
-      command(:remove_peer, @peer_id)
+      replication_admin.remove_peer(@peer_id)
     end
 
     define_test "add_peer: multiple zk cluster key" do
       cluster_key = "zk1,zk2,zk3:2182:/hbase-prod"
 
-      command(:add_peer, @peer_id, cluster_key)
+      replication_admin.add_peer(@peer_id, cluster_key)
 
-      assert_equal(1, command(:list_peers).length)
-      assert(command(:list_peers).key?(@peer_id))
-      assert_equal(cluster_key, command(:list_peers).fetch(@peer_id))
+      assert_equal(1, replication_admin.list_peers.length)
+      assert(replication_admin.list_peers.key?(@peer_id))
+      assert_equal(replication_admin.list_peers.fetch(@peer_id), cluster_key)
 
       # cleanup for future tests
-      command(:remove_peer, @peer_id)
+      replication_admin.remove_peer(@peer_id)
     end
 
     define_test "add_peer: multiple zk cluster key and table_cfs" do
       cluster_key = "zk4,zk5,zk6:11000:/hbase-test"
       table_cfs_str = "table1;table2:cf1;table3:cf2,cf3"
 
-      command(:add_peer, @peer_id, cluster_key, table_cfs_str)
+      replication_admin.add_peer(@peer_id, cluster_key, table_cfs_str)
 
-      assert_equal(1, command(:list_peers).length)
-      assert(command(:list_peers).key?(@peer_id))
-      assert_equal(cluster_key, command(:list_peers).fetch(@peer_id))
-      assert_equal(table_cfs_str, command(:show_peer_tableCFs, @peer_id))
+      assert_equal(1, replication_admin.list_peers.length)
+      assert(replication_admin.list_peers.key?(@peer_id))
+      assert_equal(cluster_key, replication_admin.list_peers.fetch(@peer_id))
+      assert_equal(table_cfs_str, replication_admin.show_peer_tableCFs(@peer_id))
 
       # cleanup for future tests
-      command(:remove_peer, @peer_id)
+      replication_admin.remove_peer(@peer_id)
     end
 
     define_test "add_peer: single zk cluster key - peer config" do
       cluster_key = "server1.cie.com:2181:/hbase"
 
       args = { CLUSTER_KEY => cluster_key }
-      command(:add_peer, @peer_id, args)
+      replication_admin.add_peer(@peer_id, args)
 
-      assert_equal(1, command(:list_peers).length)
-      assert(command(:list_peers).key?(@peer_id))
-      assert_equal(cluster_key, command(:list_peers).fetch(@peer_id))
+      assert_equal(1, replication_admin.list_peers.length)
+      assert(replication_admin.list_peers.key?(@peer_id))
+      assert_equal(cluster_key, replication_admin.list_peers.fetch(@peer_id))
 
       # cleanup for future tests
-      command(:remove_peer, @peer_id)
+      replication_admin.remove_peer(@peer_id)
     end
 
     define_test "add_peer: multiple zk cluster key - peer config" do
       cluster_key = "zk1,zk2,zk3:2182:/hbase-prod"
 
       args = { CLUSTER_KEY => cluster_key }
-      command(:add_peer, @peer_id, args)
+      replication_admin.add_peer(@peer_id, args)
 
-      assert_equal(1, command(:list_peers).length)
-      assert(command(:list_peers).key?(@peer_id))
-      assert_equal(cluster_key, command(:list_peers).fetch(@peer_id))
+      assert_equal(1, replication_admin.list_peers.length)
+      assert(replication_admin.list_peers.key?(@peer_id))
+      assert_equal(cluster_key, replication_admin.list_peers.fetch(@peer_id))
 
       # cleanup for future tests
-      command(:remove_peer, @peer_id)
+      replication_admin.remove_peer(@peer_id)
     end
 
     define_test "add_peer: multiple zk cluster key and table_cfs - peer config" do
@@ -147,15 +147,15 @@ module Hbase
       table_cfs_str = "table1;table2:cf1;table3:cf1,cf2"
 
       args = { CLUSTER_KEY => cluster_key, TABLE_CFS => table_cfs }
-      command(:add_peer, @peer_id, args)
+      replication_admin.add_peer(@peer_id, args)
 
-      assert_equal(1, command(:list_peers).length)
-      assert(command(:list_peers).key?(@peer_id))
-      assert_equal(cluster_key, command(:list_peers).fetch(@peer_id))
-      assert_equal(table_cfs_str, command(:show_peer_tableCFs, @peer_id))
+      assert_equal(1, replication_admin.list_peers.length)
+      assert(replication_admin.list_peers.key?(@peer_id))
+      assert_equal(cluster_key, replication_admin.list_peers.fetch(@peer_id))
+      assert_equal(table_cfs_str, replication_admin.show_peer_tableCFs(@peer_id))
 
       # cleanup for future tests
-      command(:remove_peer, @peer_id)
+      replication_admin.remove_peer(@peer_id)
     end
 
     define_test "add_peer: should fail when args is a hash and peer_tableCFs provided" do
@@ -164,51 +164,51 @@ module Hbase
 
       assert_raise(ArgumentError) do
         args = { CLUSTER_KEY => cluster_key }
-        command(:add_peer, @peer_id, args, table_cfs_str)
+        replication_admin.add_peer(@peer_id, args, table_cfs_str)
       end
     end
 
     define_test "get_peer_config: works with simple clusterKey peer" do
       cluster_key = "localhost:2181:/hbase-test"
       args = { CLUSTER_KEY => cluster_key }
-      command(:add_peer, @peer_id, args)
-      peer_config = command(:get_peer_config, @peer_id)
+      replication_admin.add_peer(@peer_id, args)
+      peer_config = replication_admin.get_peer_config(@peer_id)
       assert_equal(cluster_key, peer_config.get_cluster_key)
       #cleanup
-      command(:remove_peer, @peer_id)
+      replication_admin.remove_peer(@peer_id)
     end
 
     define_test "get_peer_config: works with replicationendpointimpl peer and config params"
do
       repl_impl = "org.apache.hadoop.hbase.replication.ReplicationEndpointForTest"
       config_params = { "config1" => "value1", "config2" => "value2" }
       args = { ENDPOINT_CLASSNAME => repl_impl, CONFIG => config_params}
-      command(:add_peer, @peer_id, args)
-      peer_config = command(:get_peer_config, @peer_id)
+      replication_admin.add_peer(@peer_id, args)
+      peer_config = replication_admin.get_peer_config(@peer_id)
       assert_equal(repl_impl, peer_config.get_replication_endpoint_impl)
       assert_equal(2, peer_config.get_configuration.size)
       assert_equal("value1", peer_config.get_configuration.get("config1"))
       #cleanup
-      command(:remove_peer, @peer_id)
+      replication_admin.remove_peer(@peer_id)
     end
 
     define_test "list_peer_configs: returns all peers' ReplicationPeerConfig objects" do
       cluster_key = "localhost:2181:/hbase-test"
       args = { CLUSTER_KEY => cluster_key }
       peer_id_second = '2'
-      command(:add_peer, @peer_id, args)
+      replication_admin.add_peer(@peer_id, args)
 
       repl_impl = "org.apache.hadoop.hbase.replication.ReplicationEndpointForTest"
       config_params = { "config1" => "value1", "config2" => "value2" }
       args2 = { ENDPOINT_CLASSNAME => repl_impl, CONFIG => config_params}
-      command(:add_peer, peer_id_second, args2)
+      replication_admin.add_peer(peer_id_second, args2)
 
-      peer_configs = command(:list_peer_configs)
+      peer_configs = replication_admin.list_peer_configs
       assert_equal(2, peer_configs.size)
       assert_equal(cluster_key, peer_configs.get(@peer_id).get_cluster_key)
       assert_equal(repl_impl, peer_configs.get(peer_id_second).get_replication_endpoint_impl)
       #cleanup
-      command(:remove_peer, @peer_id)
-      command(:remove_peer, peer_id_second)
+      replication_admin.remove_peer(@peer_id)
+      replication_admin.remove_peer(peer_id_second)
     end
 
     define_test "update_peer_config: can update peer config and data" do
@@ -216,7 +216,7 @@ module Hbase
       config_params = { "config1" => "value1", "config2" => "value2" }
       data_params = {"data1" => "value1", "data2" => "value2"}
       args = { ENDPOINT_CLASSNAME => repl_impl, CONFIG => config_params, DATA =>
data_params}
-      command(:add_peer, @peer_id, args)
+      replication_admin.add_peer(@peer_id, args)
 
       #Normally the ReplicationSourceManager will call ReplicationPeer#peer_added, but here
we have to do it ourselves
       replication_admin.peer_added(@peer_id)
@@ -224,12 +224,12 @@ module Hbase
       new_config_params = { "config1" => "new_value1" }
       new_data_params = {"data1" => "new_value1"}
       new_args = {CONFIG => new_config_params, DATA => new_data_params}
-      command(:update_peer_config, @peer_id, new_args)
+      replication_admin.update_peer_config(@peer_id, new_args)
 
       #Make sure the updated key/value pairs in config and data were successfully updated,
and that those we didn't
       #update are still there and unchanged
-      peer_config = command(:get_peer_config, @peer_id)
-      command(:remove_peer, @peer_id)
+      peer_config = replication_admin.get_peer_config(@peer_id)
+      replication_admin.remove_peer(@peer_id)
       assert_equal("new_value1", peer_config.get_configuration.get("config1"))
       assert_equal("value2", peer_config.get_configuration.get("config2"))
       assert_equal("new_value1", Bytes.to_string(peer_config.get_peer_data.get(Bytes.toBytes("data1"))))
@@ -239,17 +239,17 @@ module Hbase
     # assert_raise fails on native exceptions - https://jira.codehaus.org/browse/JRUBY-5279
     # Can't catch native Java exception with assert_raise in JRuby 1.6.8 as in the test below.
     # define_test "add_peer: adding a second peer with same id should error" do
-    #   command(:add_peer, @peer_id, '')
-    #   assert_equal(1, command(:list_peers).length)
+    #   replication_admin.add_peer(@peer_id, '')
+    #   assert_equal(1, replication_admin.list_peers.length)
     #
     #   assert_raise(java.lang.IllegalArgumentException) do
-    #     command(:add_peer, @peer_id, '')
+    #     replication_admin.add_peer(@peer_id, '')
     #   end
     #
-    #   assert_equal(1, command(:list_peers).length, 1)
+    #   assert_equal(1, replication_admin.list_peers.length, 1)
     #
     #   # cleanup for future tests
-    #   command(:remove_peer, @peer_id)
+    #   replication_admin.remove_peer(@peer_id)
     # end
   end
 end

http://git-wip-us.apache.org/repos/asf/hbase/blob/48492ec7/hbase-shell/src/test/ruby/hbase/visibility_labels_admin_test.rb
----------------------------------------------------------------------
diff --git a/hbase-shell/src/test/ruby/hbase/visibility_labels_admin_test.rb b/hbase-shell/src/test/ruby/hbase/visibility_labels_admin_test.rb
index e46c633..ca906b2 100644
--- a/hbase-shell/src/test/ruby/hbase/visibility_labels_admin_test.rb
+++ b/hbase-shell/src/test/ruby/hbase/visibility_labels_admin_test.rb
@@ -45,37 +45,37 @@ module Hbase
     define_test "Labels should be created as specified" do
       label = 'TEST_LABELS'
       count = table('hbase:labels')._count_internal
-      command(:add_labels, 'test_label')
+      visibility_admin.add_labels('test_label')
       assert_equal(count + 1, table('hbase:labels')._count_internal)
     end
 
     define_test "The set/clear methods should work with authorizations" do
       label = 'TEST_AUTHS'
       user = org.apache.hadoop.hbase.security.User.getCurrent().getName();
-      command(:add_labels, label)
+      visibility_admin.add_labels(label)
       $TEST_CLUSTER.waitLabelAvailable(10000, label)
-      count = command(:get_auths, user).length
+      count = visibility_admin.get_auths(user).length
 
       # verifying the set functionality
-      command(:set_auths, user, label)
-      assert_equal(count + 1, command(:get_auths, user).length)
+      visibility_admin.set_auths(user, label)
+      assert_equal(count + 1, visibility_admin.get_auths(user).length)
       assert_block do
-        command(:get_auths, user).any? {
+        visibility_admin.get_auths(user).any? {
           |auth| org.apache.hadoop.hbase.util.Bytes::toStringBinary(auth.toByteArray) ==
label
         }
       end
 
       # verifying the clear functionality
-      command(:clear_auths, user, label)
-      assert_equal(count, command(:get_auths, user).length)
+      visibility_admin.clear_auths(user, label)
+      assert_equal(count, visibility_admin.get_auths(user).length)
     end
 
     define_test "The get/put methods should work for data written with Visibility" do
       label = 'TEST_VISIBILITY'
       user = org.apache.hadoop.hbase.security.User.getCurrent().getName();
-      command(:add_labels, label)
+      visibility_admin.add_labels(label)
       $TEST_CLUSTER.waitLabelAvailable(10000, label)
-      command(:set_auths, user, label)
+      visibility_admin.set_auths(user, label)
 
       # verifying put functionality
       @test_table.put(1, "x:a", 31, {VISIBILITY=>label})

http://git-wip-us.apache.org/repos/asf/hbase/blob/48492ec7/hbase-shell/src/test/ruby/shell/formatter_test.rb
----------------------------------------------------------------------
diff --git a/hbase-shell/src/test/ruby/shell/formatter_test.rb b/hbase-shell/src/test/ruby/shell/formatter_test.rb
index 540dd09..7010479 100644
--- a/hbase-shell/src/test/ruby/shell/formatter_test.rb
+++ b/hbase-shell/src/test/ruby/shell/formatter_test.rb
@@ -63,6 +63,6 @@ class ShellFormatterTest < Test::Unit::TestCase
   end
 
   define_test "Froematter#footer should work" do
-    formatter.footer()
+    formatter.footer(Time.now - 5)
   end
 end

http://git-wip-us.apache.org/repos/asf/hbase/blob/48492ec7/hbase-shell/src/test/ruby/shell/shell_test.rb
----------------------------------------------------------------------
diff --git a/hbase-shell/src/test/ruby/shell/shell_test.rb b/hbase-shell/src/test/ruby/shell/shell_test.rb
index 6bf619c..689a18b 100644
--- a/hbase-shell/src/test/ruby/shell/shell_test.rb
+++ b/hbase-shell/src/test/ruby/shell/shell_test.rb
@@ -26,12 +26,12 @@ class ShellTest < Test::Unit::TestCase
     @shell = Shell::Shell.new(@hbase)
   end
 
-  define_test "Shell::Shell#admin should return an admin instance" do
-    assert_kind_of(Hbase::Admin, @shell.admin)
+  define_test "Shell::Shell#hbase_admin should return an admin instance" do
+    assert_kind_of(Hbase::Admin, @shell.hbase_admin)
   end
 
-  define_test "Shell::Shell#admin should cache admin instances" do
-    assert_same(@shell.admin, @shell.admin)
+  define_test "Shell::Shell#hbase_admin should cache admin instances" do
+    assert_same(@shell.hbase_admin, @shell.hbase_admin)
   end
 
   #-------------------------------------------------------------------------------
@@ -44,10 +44,6 @@ class ShellTest < Test::Unit::TestCase
     assert_not_same(@shell.hbase_table('hbase:meta'), @shell.hbase_table('hbase:meta'))
   end
 
-  define_test "Shell::Shell#hbase attribute is a HBase instance" do
-    assert_kind_of(Hbase::Hbase, @shell.hbase)
-  end
-
   #-------------------------------------------------------------------------------
 
   define_test "Shell::Shell#export_commands should export command methods to specified object"
do

http://git-wip-us.apache.org/repos/asf/hbase/blob/48492ec7/hbase-shell/src/test/ruby/test_helper.rb
----------------------------------------------------------------------
diff --git a/hbase-shell/src/test/ruby/test_helper.rb b/hbase-shell/src/test/ruby/test_helper.rb
index 3ed9325..179ee5b 100644
--- a/hbase-shell/src/test/ruby/test_helper.rb
+++ b/hbase-shell/src/test/ruby/test_helper.rb
@@ -43,24 +43,19 @@ module Hbase
 
     def setup_hbase
       hbase = ::Hbase::Hbase.new($TEST_CLUSTER.getConfiguration)
-      @shell = ::Shell::Shell.new(hbase, interactive = false)
+      @shell = ::Shell::Shell.new(hbase)
     end
     
     def shutdown
       @shell.hbase.shutdown
     end
 
-    # This function triggers exactly same path as the users.
-    def command(command, *args)
-      @shell.command(command, *args)
-    end
-
     def table(table)
       @shell.hbase_table(table)
     end
 
     def admin
-      @shell.admin
+      @shell.hbase_admin
     end
 
     def taskmonitor
@@ -86,7 +81,7 @@ module Hbase
     def create_test_table(name)
       # Create the table if needed
       unless admin.exists?(name)
-        command(:create, name, {'NAME' => 'x', 'VERSIONS' => 5}, 'y')
+        admin.create name, [{'NAME' => 'x', 'VERSIONS' => 5}, 'y']
         return
       end
 
@@ -99,7 +94,7 @@ module Hbase
     def create_test_table_with_splits(name, splits)
       # Create the table if needed
       unless admin.exists?(name)
-        command(:create, name, 'f1', splits)
+        admin.create name, 'f1', splits
       end
 
       # Enable the table if needed
@@ -133,18 +128,6 @@ module Hbase
         puts "IGNORING DELETE ALL SNAPSHOT ERROR: #{e}"
       end
     end
-
-
-    def capture_stdout
-      begin
-        old_stdout = $stdout
-        $stdout = StringIO.new('','w')
-        yield
-        $stdout.string
-      ensure
-        $stdout = old_stdout
-      end
-    end
   end
 end
 


Mime
View raw message