diff --git a/lib/MetaCPAN/Role/Script.pm b/lib/MetaCPAN/Role/Script.pm
index da11e0890..102f80174 100644
--- a/lib/MetaCPAN/Role/Script.pm
+++ b/lib/MetaCPAN/Role/Script.pm
@@ -6,7 +6,7 @@ use ElasticSearchX::Model::Document::Types qw(:all);
 use Git::Helpers qw( checkout_root );
 use Log::Contextual qw( :log :dlog );
 use MetaCPAN::Model ();
-use MetaCPAN::Types::TypeTiny qw( Bool Int Path Str );
+use MetaCPAN::Types::TypeTiny qw( Bool HashRef Int Path Str );
 use Mojo::Server ();
 use Term::ANSIColor qw( colored );
 use IO::Interactive qw( is_interactive );
@@ -35,6 +35,22 @@ has die_on_error => (
     documentation => 'Die on errors instead of simply logging',
 );
 
+has exit_code => (
+    isa           => Int,
+    is            => 'rw',
+    default       => 0,
+    documentation => 'Exit Code to be returned on termination',
+);
+
+has arg_await_timeout => (
+    init_arg      => 'await',
+    is            => 'ro',
+    isa           => Int,
+    default       => 15,
+    documentation =>
+        'seconds before connection is considered failed with timeout',
+);
+
 has ua => (
     is      => 'ro',
     lazy    => 1,
@@ -71,6 +87,27 @@ has index => (
         'Index to use, defaults to "cpan" (when used: also export ES_SCRIPT_INDEX)',
 );
 
+has cluster_info => (
+    isa     => HashRef,
+    traits  => ['Hash'],
+    is      => 'rw',
+    default => sub { {} },
+);
+
+has indices_info => (
+    isa     => HashRef,
+    traits  => ['Hash'],
+    is      => 'rw',
+    default => sub { {} },
+);
+
+has aliases_info => (
+    isa     => HashRef,
+    traits  => ['Hash'],
+    is      => 'rw',
+    default => sub { {} },
+);
+
 has port => (
     isa           => Int,
     is            => 'ro',
@@ -123,13 +160,27 @@ sub BUILDARGS {
 }
 
 sub handle_error {
-    my ( $self, $error ) = @_;
+    my ( $self, $error, $die_always ) = @_;
+
+    # Die if configured (for the test suite).
+    $die_always = $self->die_on_error unless defined $die_always;
 
     # Always log.
     log_fatal {$error};
 
-    # Die if configured (for the test suite).
-    Carp::croak $error if $self->die_on_error;
+    $! = $self->exit_code if ( $self->exit_code != 0 );
+
+    Carp::croak $error if $die_always;
+}
+
+sub print_error {
+    my ( $self, $error ) = @_;
+
+    # Always log.
+    log_error {$error};
+
+    # Display Error in red
+    print colored( ['bold red'], "*** ERROR ***: $error" ), "\n";
 }
 
 sub index {
@@ -195,6 +246,122 @@ before run => sub {
     #Dlog_debug {"Connected to $_"} $self->remote;
 };
 
+sub _get_indices_info {
+    my ( $self, $irefresh ) = @_;
+
+    if ( $irefresh || scalar( keys %{ $self->indices_info } ) == 0 ) {
+        my $sinfo_rs = $self->es->cat->indices( h => [ 'index', 'health' ] );
+        my $sindices_parsing = qr/^([^[:space:]]+) +([^[:space:]]+)/m;
+
+        $self->indices_info( {} );
+
+        while ( $sinfo_rs =~ /$sindices_parsing/g ) {
+            $self->indices_info->{$1}
+                = { 'index_name' => $1, 'health' => $2 };
+        }
+    }
+}
+
+sub _get_aliases_info {
+    my ( $self, $irefresh ) = @_;
+
+    if ( $irefresh || scalar( keys %{ $self->aliases_info } ) == 0 ) {
+        my $sinfo_rs = $self->es->cat->aliases( h => [ 'alias', 'index' ] );
+        my $saliases_parsing = qr/^([^[:space:]]+) +([^[:space:]]+)/m;
+
+        $self->aliases_info( {} );
+
+        while ( $sinfo_rs =~ /$saliases_parsing/g ) {
+            $self->aliases_info->{$1} = { 'alias_name' => $1, 'index' => $2 };
+        }
+    }
+}
+
+sub check_health {
+    my ( $self, $irefresh ) = @_;
+    my $ihealth = 0;
+
+    $irefresh = 0 unless ( defined $irefresh );
+
+    $ihealth = $self->await;
+
+    if ($ihealth) {
+        $self->_get_indices_info($irefresh);
+
+        foreach ( keys %{ $self->indices_info } ) {
+            $ihealth = 0
+                if ( $self->indices_info->{$_}->{'health'} eq 'red' );
+        }
+    }
+
+    if ($ihealth) {
+        $self->_get_aliases_info($irefresh);
+
+        $ihealth = 0 if ( scalar( keys %{ $self->aliases_info } ) == 0 );
+    }
+
+    return $ihealth;
+}
+
+sub await {
+    my $self   = $_[0];
+    my $iready = 0;
+
+    if ( scalar( keys %{ $self->cluster_info } ) == 0 ) {
+        my $es       = $self->es;
+        my $iseconds = 0;
+
+        log_info {"Awaiting Elasticsearch ..."};
+
+        do {
+            eval {
+                $iready = $es->ping;
+
+                if ($iready) {
+                    log_info {
+                        "Awaiting $iseconds / "
+                            . $self->arg_await_timeout
+                            . " : ready"
+                    };
+
+                    $self->cluster_info( \%{ $es->info } );
+                }
+            };
+
+            if ($@) {
+                if ( $iseconds < $self->arg_await_timeout ) {
+                    log_info {
+                        "Awaiting $iseconds / "
+                            . $self->arg_await_timeout
+                            . " : unavailable - sleeping ..."
+                    };
+
+                    sleep(1);
+
+                    $iseconds++;
+                }
+                else {
+                    log_error {
+                        "Awaiting $iseconds / "
+                            . $self->arg_await_timeout
+                            . " : unavailable - timeout!"
+                    };
+
+                    #Set System Error: 112 - EHOSTDOWN - Host is down
+                    $self->exit_code(112);
+                    $self->handle_error( $@, 1 );
+                }
+            }
+        } while ( !$iready && $iseconds <= $self->arg_await_timeout );
+    }
+    else {
+        #ElasticSearch Service is available
+        $iready = 1;
+    }
+
+    return $iready;
+}
+
 sub are_you_sure {
     my ( $self, $msg ) = @_;
 
@@ -216,8 +383,82 @@ __END__
 
 =pod
 
+=head1 NAME
+
+MetaCPAN::Role::Script - Base Role which is used by many command line applications
+
 =head1 SYNOPSIS
 
 Roles which should be available to all modules.
 
+=head1 OPTIONS
+
+This Role makes the command line application accept the following options
+
+=over 4
+
+=item Option C<--await 15>
+
+This option will set the I<ElasticSearch Availability Check Timeout>.
+After C<await> seconds the Application will fail with an Exception and the Exit Code [112]
+(C<112 - EHOSTDOWN - Host is down>) will be returned
+
+    bin/metacpan <script_name> --await 15
+
+See L<Method C<await()>>
+
+=back
+
+=head1 METHODS
+
+This Role provides the following methods
+
+=over 4
+
+=item C<await()>
+
+This method uses the
+L<C<Search::Elasticsearch::Client::2_0::Direct::ping()>|https://metacpan.org/pod/Search::Elasticsearch::Client::2_0::Direct#ping()>
+method to verify the service availabilty and wait for C<arg_await_timeout> seconds.
+When the service does not become available within C<arg_await_timeout> seconds it re-throws the
+Exception from the C<Search::Elasticsearch::Client> and sets C< $! > to C< 112 >.
+The C<Search::Elasticsearch::Client> generates a C<"Search::Elasticsearch::Error::NoNodes"> Exception.
+When the service is available it will populate the C<cluster_info> C<HASH> structure with the basic information
+about the cluster.
+See L<Option C<--await 15>>
+See L<Method C<check_health()>>
+
+=item C<check_health( [ refresh ] )>
+
+This method uses the
+L<C<Search::Elasticsearch::Client::2_0::Direct::cat()>|https://metacpan.org/pod/Search::Elasticsearch::Client::2_0::Direct#cat()>
+method to collect basic data about the cluster structure as the general information,
+the health state of the indices and the created aliases.
+This information is stored in C<cluster_info>, C<indices_info> and C<aliases_info> as C<HASH> structures.
+If the parameter C<refresh> is set to C< 1 > the structures C<indices_info> and C<aliases_info> will always
+be updated.
+If the C<cluster_info> structure is empty it calls first the C<await()> method.
+If the service is unavailable the C<await()> method will produce an exception and the structures will be empty
+The method returns C< 1 > when the C<cluster_info> is populated, none of the indices in C<indices_info> has
+the Health State I<red> and at least one alias is created in C<aliases_info>
+otherwise the method returns C< 0 >
+
+=item C<are_you_sure()>
+
+Requests the user to confirm the operation with "I< YES >"
+
+=item C<handle_error( error_message[, die_always ] )>
+
+Logs the string C<error_message> with the log function as fatal error.
+If C<exit_code> is not equel C< 0 > sets its value in C< $! >.
+If the option C<--die_on_error> is enabled it throws an Exception with C<error_message>.
+If the parameter C<die_always> is set it overrides the option C<--die_on_error>.
+
+=item C<print_error( error_message )>
+
+Logs the string C<error_message> with the log function and displays it in red.
+But it does not end the application.
+
+=back
+
 =cut
diff --git a/lib/MetaCPAN/Script/Mapping.pm b/lib/MetaCPAN/Script/Mapping.pm
index e8eb50408..7e4f47f29 100644
--- a/lib/MetaCPAN/Script/Mapping.pm
+++ b/lib/MetaCPAN/Script/Mapping.pm
@@ -45,6 +45,14 @@ has arg_list_types => (
     documentation => 'list available index type names',
 );
 
+has arg_cluster_info => (
+    init_arg      => 'show_cluster_info',
+    is            => 'ro',
+    isa           => Bool,
+    default       => 0,
+    documentation => 'show basic info about cluster, indices and aliases',
+);
+
 has arg_create_index => (
     init_arg      => 'create_index',
     is            => 'ro',
@@ -121,14 +129,31 @@ has delete_from_type => (
 );
 
 sub run {
-    my $self = shift;
-    $self->create_index   if $self->arg_create_index;
-    $self->delete_index   if $self->arg_delete_index;
-    $self->update_index   if $self->arg_update_index;
-    $self->copy_type      if $self->copy_to_index;
-    $self->empty_type     if $self->delete_from_type;
-    $self->list_types     if $self->arg_list_types;
-    $self->deploy_mapping if $self->arg_deploy_mapping;
+    my $self   = shift;
+
+    if ( $self->await ) {
+        $self->delete_index if $self->arg_delete_index;
+        $self->update_index if $self->arg_update_index;
+        $self->copy_type    if $self->copy_to_index;
+        $self->empty_type   if $self->delete_from_type;
+        $self->list_types   if $self->arg_list_types;
+
+        if ( $self->arg_deploy_mapping ) {
+            unless ( $self->deploy_mapping ) {
+                $self->print_error("Indices Re-creation has failed!");
+                $self->exit_code(1);
+            }
+        }
+
+        if ( $self->arg_cluster_info ) {
+            $self->check_health;
+            $self->show_info;
+        }
+    }
+
+    # Correctly reaching this point it will end the application
+    # with the set MetaCPAN::Role::Script::exit_code
+    exit $self->exit_code;
 }
 
 sub _check_index_exists {
@@ -158,6 +183,7 @@ sub delete_index {
 
 sub _delete_index {
     my ( $self, $name ) = @_;
+
     log_info {"Deleting index: $name"};
     $self->es->indices->delete( index => $name );
 }
@@ -369,9 +395,20 @@ sub list_types {
     print "$_\n" for sort keys %{ $self->index->types };
 }
 
+sub show_info {
+    my $self    = $_[0];
+    my $info_rs = {
+        'cluster_info' => \%{ $self->cluster_info },
+        'indices_info' => \%{ $self->indices_info },
+        'aliases_info' => \%{ $self->aliases_info }
+    };
+    print JSON->new->utf8->pretty->encode($info_rs);
+}
+
 sub deploy_mapping {
     my $self       = shift;
     my $cpan_index = 'cpan_v1_01';
+    my $imappingok = 0;
 
     $self->are_you_sure(
         'this will delete EVERYTHING and re-create the (empty) indexes');
@@ -446,16 +483,89 @@ sub deploy_mapping {
         }
     }
 
-    # create alias
+    # create aliases
 
-    $es->indices->put_alias(
-        index => $cpan_index,
-        name  => 'cpan',
-    );
+    my %aliases = ( 'cpan' => $cpan_index );
+    for my $alias ( sort keys %aliases ) {
+        log_info {"Creating alias: '$alias' -> '$aliases{$alias}'"};
+        $es->indices->put_alias(
+            index => $aliases{$alias},
+            name  => $alias,
+        );
+    }
+
+    $self->check_health(1);
+    $imappingok = $self->verify_mapping( \%mappings, \%aliases );
 
     # done
     log_info {"Done."};
-    1;
+
+    return $imappingok;
+}
+
+sub verify_mapping {
+    my ( $self, $rmappings, $raliases ) = @_;
+    my $ihealth = 0;
+
+    if ( defined $rmappings && ref $rmappings eq 'HASH' ) {
+        my $rhealth = undef;
+
+        $ihealth = 1;
+
+        for my $idx ( sort keys %$rmappings ) {
+            $rhealth = $self->indices_info->{$idx};
+            if ( defined $rhealth ) {
+                if ( $rhealth->{'health'} eq 'red' ) {
+                    log_error {
+                        "Broken index: $idx (state '"
+                            . $rhealth->{'health'} . "')"
+                    };
+                    $ihealth = 0;
+                }
+                else {
+                    log_info {
+                        "Healthy index: $idx (state '"
+                            . $rhealth->{'health'} . "')"
+                    };
+                }
+            }
+            else {
+                log_error {"Missing index: $idx"};
+                $ihealth = 0;
+            }
+        }
+    }
+
+    if ( defined $raliases && ref $raliases eq 'HASH' ) {
+        my $ralias = undef;
+        for my $name ( sort keys %$raliases ) {
+            $ralias = $self->aliases_info->{$name};
+            if ( defined $ralias ) {
+                if ( $ralias->{'index'} eq $raliases->{$name} ) {
+                    log_info {
+                        "Correct alias: $name (index '"
+                            . $ralias->{'index'} . "')"
+                    };
+                }
+                else {
+                    log_error {
+                        "Broken alias: $name (index '"
+                            . $ralias->{'index'} . "')"
+                    };
+                    $ihealth = 0;
+                }
+            }
+            else {
+                log_error {"Missing alias: $name"};
+                $ihealth = 0;
+            }
+        }
+    }
+    else {
+        $ihealth = 0 if ( scalar( keys %{ $self->aliases_info } ) == 0 );
+    }
+
+    return $ihealth;
 }
 
 __PACKAGE__->meta->make_immutable;
@@ -463,8 +573,15 @@ __PACKAGE__->meta->make_immutable;
 
 __END__
 
+=pod
+
+=head1 NAME
+
+MetaCPAN::Script::Mapping - Script to set the index and mapping the types
+
 =head1 SYNOPSIS
 
+ # bin/metacpan mapping --show_cluster_info   # show basic info about the cluster, indices and aliases
  # bin/metacpan mapping --delete
  # bin/metacpan mapping --list_types
  # bin/metacpan mapping --delete_index xxx
@@ -481,3 +598,91 @@ __END__
 This is the index mapping handling script.
 Used rarely, but carries the most important task of setting
 the index and mapping the types.
+
+=head1 OPTIONS
+
+This Script accepts the following options
+
+=over 4
+
+=item Option C<--show_cluster_info>
+
+This option makes the Script show basic information about the I<ElasticSearch> Cluster
+and its indices and aliases.
+This information has to be collected with the C<MetaCPAN::Role::Script::check_health()> Method.
+On Script start-up it is empty.
+
+    bin/metacpan mapping --show_cluster_info
+
+See L<Method C<MetaCPAN::Role::Script::check_health()>>
+
+=item Option C<--delete>
+
+This option makes the Script delete all indices configured in the project and re-create them emtpy.
+It verifies the index integrity of the indices and aliases calling the methods
+C<MetaCPAN::Role::Script::check_health()> and C<verify_mapping()>.
+If the C<verify_mapping()> Method fails it exits the Script
+with B<Exit Code> C< 1 >.
+
+    bin/metacpan mapping --delete
+
+See L<Method C<deploy_mapping()>>
+
+See L<Method C<verify_mapping()>>
+
+See L<Method C<MetaCPAN::Role::Script::check_health()>>
+
+=back
+
+=head1 METHODS
+
+This Package provides the following methods
+
+=over 4
+
+=item C<deploy_mapping()>
+
+Deletes and re-creates the indices and aliases defined in the Project.
+The user will be requested for manual confirmation on the command line before the elemination.
+The integrity of the indices and aliases will be checked with the C<verify_mapping()> Method.
+On successful creation it returns C< 1 >, otherwise it returns C< 0 >.
+
+B<Returns:> It returns C< 1 > when the indices and aliases are created and verified as correct.
+Otherwise it returns C< 0 >.
+
+B<Exceptions:> It can throw exceptions when the connection to I<ElasticSearch> fails
+or there is any issue in any I<ElasticSearch> Request run by the Script.
+
+See L<Option C<--delete>>
+
+See L<Method C<verify_mapping()>>
+
+See L<Method C<MetaCPAN::Role::Script::check_health()>>
+
+=item C<verify_mapping( \%indices, \%aliases )>
+
+Checks the defined indices and aliases against the actually in the I<ElasticSearch> Cluster
+existing indices and aliases which must have been requested with
+the C<MetaCPAN::Role::Script::check_health()> Method.
+
+B<Parameters:>
+
+C<\%indices> - Reference to a hash that defines the indices required for the Project.
+
+C<\%aliases> - Reference to a hash that defines the aliases required for the Project.
+
+B<Returns:> It returns C< 1 > when the indices and aliases are created and verified as correct.
+Otherwise it returns C< 0 >.
+
+B<Exceptions:> It can throw exceptions when the connection to I<ElasticSearch> fails
+or there is any issue in any I<ElasticSearch> Request run by the Script.
+
+See L<Option C<--delete>>
+
+See L<Method C<verify_mapping()>>
+
+See L<Method C<MetaCPAN::Role::Script::check_health()>>
+
+=back
+
+=cut