← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/slave.cc

Merged from gettextize.

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/slave.cc
88
88
static const char *reconnect_messages[SLAVE_RECON_ACT_MAX][SLAVE_RECON_MSG_MAX]=
89
89
{
90
90
  {
91
 
    gettext_noop("Waiting to reconnect after a failed registration on master"),
92
 
    gettext_noop("Slave I/O thread killed while waitnig to reconnect after a "
 
91
    N_("Waiting to reconnect after a failed registration on master"),
 
92
    N_("Slave I/O thread killed while waitnig to reconnect after a "
93
93
                 "failed registration on master"),
94
 
    gettext_noop("Reconnecting after a failed registration on master"),
95
 
    gettext_noop("failed registering on master, reconnecting to try again, "
 
94
    N_("Reconnecting after a failed registration on master"),
 
95
    N_("failed registering on master, reconnecting to try again, "
96
96
                 "log '%s' at postion %s"),
97
97
    "COM_REGISTER_SLAVE",
98
 
    gettext_noop("Slave I/O thread killed during or after reconnect")
 
98
    N_("Slave I/O thread killed during or after reconnect")
99
99
  },
100
100
  {
101
 
    gettext_noop("Waiting to reconnect after a failed binlog dump request"),
102
 
    gettext_noop("Slave I/O thread killed while retrying master dump"),
103
 
    gettext_noop("Reconnecting after a failed binlog dump request"),
104
 
    gettext_noop("failed dump request, reconnecting to try again, "
 
101
    N_("Waiting to reconnect after a failed binlog dump request"),
 
102
    N_("Slave I/O thread killed while retrying master dump"),
 
103
    N_("Reconnecting after a failed binlog dump request"),
 
104
    N_("failed dump request, reconnecting to try again, "
105
105
                 "log '%s' at postion %s"),
106
106
    "COM_BINLOG_DUMP",
107
 
    gettext_noop("Slave I/O thread killed during or after reconnect")
 
107
    N_("Slave I/O thread killed during or after reconnect")
108
108
  },
109
109
  {
110
 
    gettext_noop("Waiting to reconnect after a failed master event read"),
111
 
    gettext_noop("Slave I/O thread killed while waiting to reconnect "
 
110
    N_("Waiting to reconnect after a failed master event read"),
 
111
    N_("Slave I/O thread killed while waiting to reconnect "
112
112
                 "after a failed read"),
113
 
    gettext_noop("Reconnecting after a failed master event read"),
114
 
    gettext_noop("Slave I/O thread: Failed reading log event, "
 
113
    N_("Reconnecting after a failed master event read"),
 
114
    N_("Slave I/O thread: Failed reading log event, "
115
115
                 "reconnecting to retry, log '%s' at postion %s"),
116
116
    "",
117
 
    gettext_noop("Slave I/O thread killed during or after a "
 
117
    N_("Slave I/O thread killed during or after a "
118
118
                 "reconnect done to recover from failed read")
119
119
  }
120
120
};
615
615
    if (difftime(time(0), rli->last_event_start_time) > 60)
616
616
    {
617
617
      rli->report(ERROR_LEVEL, 0,
618
 
                  "SQL thread had to stop in an unsafe situation, in "
 
618
                  _("SQL thread had to stop in an unsafe situation, in "
619
619
                  "the middle of applying updates to a "
620
620
                  "non-transactional table without any primary key. "
621
621
                  "There is a risk of duplicate updates when the slave "
622
622
                  "SQL thread is restarted. Please check your tables' "
623
 
                  "contents after restart.");
 
623
                  "contents after restart."));
624
624
      return(1);
625
625
    }
626
626
  }
1690
1690
    {
1691
1691
      char buf[22];
1692
1692
      rli->report(ERROR_LEVEL, ER_UNKNOWN_ERROR,
1693
 
                  "It was not possible to update the positions"
 
1693
                  _("It was not possible to update the positions"
1694
1694
                  " of the relay log information: the slave may"
1695
1695
                  " be in an inconsistent state."
1696
 
                  " Stopped in %s position %s",
 
1696
                  " Stopped in %s position %s"),
1697
1697
                  rli->group_relay_log_name,
1698
1698
                  llstr(rli->group_relay_log_pos, buf));
1699
1699
      return(2);
1862
1862
  }
1863
1863
  pthread_mutex_unlock(&rli->data_lock);
1864
1864
  rli->report(ERROR_LEVEL, ER_SLAVE_RELAY_LOG_READ_FAILURE,
1865
 
              ER(ER_SLAVE_RELAY_LOG_READ_FAILURE), "\
1866
 
Could not parse relay log event entry. The possible reasons are: the master's \
1867
 
binary log is corrupted (you can check this by running 'mysqlbinlog' on the \
1868
 
binary log), the slave's relay log is corrupted (you can check this by running \
1869
 
'mysqlbinlog' on the relay log), a network problem, or a bug in the master's \
1870
 
or slave's DRIZZLE code. If you want to check the master's binary log or slave's \
1871
 
relay log, you will be able to know their names by issuing 'SHOW SLAVE STATUS' \
1872
 
on this slave.\
1873
 
");
 
1865
              ER(ER_SLAVE_RELAY_LOG_READ_FAILURE),
 
1866
              _("Could not parse relay log event entry. The possible reasons "
 
1867
                "are: the master's binary log is corrupted (you can check this "
 
1868
                "by running 'mysqlbinlog' on the binary log), the slave's "
 
1869
                "relay log is corrupted (you can check this by running "
 
1870
                "'mysqlbinlog' on the relay log), a network problem, or a bug "
 
1871
                "in the master's or slave's DRIZZLE code. If you want to check "
 
1872
                "the master's binary log or slave's relay log, you will be "
 
1873
                "able to know their names by issuing 'SHOW SLAVE STATUS' "
 
1874
                "on this slave."));
1874
1875
  return(1);
1875
1876
}
1876
1877
 
2000
2001
  if (!(mi->drizzle= drizzle = drizzle_create(NULL)))
2001
2002
  {
2002
2003
    mi->report(ERROR_LEVEL, ER_SLAVE_FATAL_ERROR,
2003
 
               ER(ER_SLAVE_FATAL_ERROR), "error in drizzle_create()");
 
2004
               ER(ER_SLAVE_FATAL_ERROR), _("error in drizzle_create()"));
2004
2005
    goto err;
2005
2006
  }
2006
2007
 
2575
2576
        {
2576
2577
          mi->report(ERROR_LEVEL, ER_SLAVE_RELAY_LOG_WRITE_FAILURE,
2577
2578
                     ER(ER_SLAVE_RELAY_LOG_WRITE_FAILURE),
2578
 
                     "error writing Exec_load event to relay log");
 
2579
                     _("error writing Exec_load event to relay log"));
2579
2580
          goto err;
2580
2581
        }
2581
2582
        mi->rli.relay_log.harvest_bytes_written(&mi->rli.log_space_total);
2589
2590
        {
2590
2591
          mi->report(ERROR_LEVEL, ER_SLAVE_RELAY_LOG_WRITE_FAILURE,
2591
2592
                     ER(ER_SLAVE_RELAY_LOG_WRITE_FAILURE),
2592
 
                     "error writing Create_file event to relay log");
 
2593
                     _("error writing Create_file event to relay log"));
2593
2594
          goto err;
2594
2595
        }
2595
2596
        cev_not_written=0;
2604
2605
        {
2605
2606
          mi->report(ERROR_LEVEL, ER_SLAVE_RELAY_LOG_WRITE_FAILURE,
2606
2607
                     ER(ER_SLAVE_RELAY_LOG_WRITE_FAILURE),
2607
 
                     "error writing Append_block event to relay log");
 
2608
                     _("error writing Append_block event to relay log"));
2608
2609
          goto err;
2609
2610
        }
2610
2611
        mi->rli.relay_log.harvest_bytes_written(&mi->rli.log_space_total) ;
2700
2701
    if (unlikely(!(tmp_buf=(char*)my_malloc(event_len+1,MYF(MY_WME)))))
2701
2702
    {
2702
2703
      mi->report(ERROR_LEVEL, ER_SLAVE_FATAL_ERROR,
2703
 
                 ER(ER_SLAVE_FATAL_ERROR), "Memory allocation failed");
 
2704
                 ER(ER_SLAVE_FATAL_ERROR), _("Memory allocation failed"));
2704
2705
      return(1);
2705
2706
    }
2706
2707
    memcpy(tmp_buf,buf,event_len);
3082
3083
err:
3083
3084
  pthread_mutex_unlock(&mi->data_lock);
3084
3085
  if (error)
3085
 
    mi->report(ERROR_LEVEL, error, ER(error), 
 
3086
    mi->report(ERROR_LEVEL, error, ER(error),
3086
3087
               (error == ER_SLAVE_RELAY_LOG_WRITE_FAILURE)?
3087
 
               "could not queue event from master" :
 
3088
               _("could not queue event from master") :
3088
3089
               error_msg.ptr());
3089
3090
  return(error);
3090
3091
}
3178
3179
      last_errno=drizzle_errno(drizzle);
3179
3180
      suppress_warnings= 0;
3180
3181
      mi->report(ERROR_LEVEL, last_errno,
3181
 
                 "error %s to master '%s@%s:%d'"
3182
 
                 " - retry-time: %d  retries: %u",
3183
 
                 (reconnect ? "reconnecting" : "connecting"),
 
3182
                 _("error %s to master '%s@%s:%d'"
 
3183
                   " - retry-time: %d  retries: %u"),
 
3184
                 (reconnect ? _("reconnecting") : _("connecting")),
3184
3185
                 mi->user, mi->host, mi->port,
3185
3186
                 mi->connect_retry, master_retry_count);
3186
3187
    }