← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/log_event.cc

  • Committer: Brian Aker
  • Date: 2008-10-08 02:16:25 UTC
  • Revision ID: brian@tangent.org-20081008021625-3756823nqs1phvsn
More effort around master.info (and relay.info)

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/log_event.cc
983
983
    case ROTATE_EVENT:
984
984
      ev = new Rotate_log_event(buf, event_len, description_event);
985
985
      break;
986
 
    case SLAVE_EVENT: /* can never happen (unused event) */
987
 
      ev = new Slave_log_event(buf, event_len);
988
 
      break;
989
986
    case CREATE_FILE_EVENT:
990
987
      ev = new Create_file_log_event(buf, event_len, description_event);
991
988
      break;
3219
3216
  if ((server_id != ::server_id || rli->replicate_same_server_id) &&
3220
3217
      !rli->is_in_group())
3221
3218
  {
3222
 
    memcpy(rli->group_master_log_name, new_log_ident, ident_len+1);
 
3219
    rli->group_master_log_name.assign(new_log_ident, ident_len+1);
3223
3220
    rli->notify_group_master_log_name_update();
3224
3221
    rli->group_master_log_pos= pos;
3225
 
    strmake(rli->group_relay_log_name, rli->event_relay_log_name,
3226
 
            sizeof(rli->group_relay_log_name) - 1);
 
3222
    rli->group_relay_log_name.assign(rli->event_relay_log_name);
3227
3223
    rli->notify_group_relay_log_name_update();
3228
3224
    rli->group_relay_log_pos= rli->event_relay_log_pos;
3229
3225
    /*
3776
3772
{
3777
3773
  char buf[256+HOSTNAME_LENGTH], *pos;
3778
3774
  pos= my_stpcpy(buf, "host=");
3779
 
  pos= my_stpncpy(pos, master_host, HOSTNAME_LENGTH);
 
3775
  pos= my_stpncpy(pos, master_host.c_str(), HOSTNAME_LENGTH);
3780
3776
  pos= my_stpcpy(pos, ",port=");
3781
3777
  pos= int10_to_str((long) master_port, pos, 10);
3782
3778
  pos= my_stpcpy(pos, ",log=");
3783
 
  pos= my_stpcpy(pos, master_log);
 
3779
  pos= my_stpcpy(pos, master_log.c_str());
3784
3780
  pos= my_stpcpy(pos, ",pos=");
3785
3781
  pos= int64_t10_to_str(master_pos, pos, 10);
3786
3782
  protocol->store(buf, pos-buf, &my_charset_bin);
3802
3798
  // TODO: re-write this better without holding both locks at the same time
3803
3799
  pthread_mutex_lock(&mi->data_lock);
3804
3800
  pthread_mutex_lock(&rli->data_lock);
3805
 
  master_host_len = strlen(mi->host);
3806
 
  master_log_len = strlen(rli->group_master_log_name);
3807
3801
  // on OOM, just do not initialize the structure and print the error
3808
3802
  if ((mem_pool = (char*)my_malloc(get_data_size() + 1,
3809
3803
                                   MYF(MY_WME))))
3810
3804
  {
3811
 
    master_host = mem_pool + SL_MASTER_HOST_OFFSET ;
3812
 
    memcpy(master_host, mi->host, master_host_len + 1);
3813
 
    master_log = master_host + master_host_len + 1;
3814
 
    memcpy(master_log, rli->group_master_log_name, master_log_len + 1);
3815
 
    master_port = mi->port;
 
3805
    master_host.assign(mi->getHostname());
 
3806
    master_log.assign(rli->group_master_log_name);
 
3807
    master_port = mi->getPort();
3816
3808
    master_pos = rli->group_master_log_pos;
3817
3809
  }
3818
3810
  else
3831
3823
 
3832
3824
int Slave_log_event::get_data_size()
3833
3825
{
3834
 
  return master_host_len + master_log_len + 1 + SL_MASTER_HOST_OFFSET;
 
3826
  return master_host.length() + master_log.length() + 1 + SL_MASTER_HOST_OFFSET;
3835
3827
}
3836
3828
 
3837
3829
 
3847
3839
}
3848
3840
 
3849
3841
 
3850
 
void Slave_log_event::init_from_mem_pool(int data_size)
 
3842
void Slave_log_event::init_from_mem_pool()
3851
3843
{
3852
3844
  master_pos = uint8korr(mem_pool + SL_MASTER_POS_OFFSET);
3853
3845
  master_port = uint2korr(mem_pool + SL_MASTER_PORT_OFFSET);
3854
 
  master_host = mem_pool + SL_MASTER_HOST_OFFSET;
3855
 
  master_host_len = strlen(master_host);
3856
 
  // safety
3857
 
  master_log = master_host + master_host_len + 1;
3858
 
  if (master_log > mem_pool + data_size)
3859
 
  {
3860
 
    master_host = 0;
3861
 
    return;
3862
 
  }
3863
 
  master_log_len = strlen(master_log);
3864
 
}
3865
 
 
3866
 
 
3867
 
/** This code is not used, so has not been updated to be format-tolerant. */
3868
 
Slave_log_event::Slave_log_event(const char* buf, uint32_t event_len)
3869
 
  :Log_event(buf,0) /*unused event*/ ,mem_pool(0),master_host(0)
3870
 
{
3871
 
  if (event_len < LOG_EVENT_HEADER_LEN)
3872
 
    return;
3873
 
  event_len -= LOG_EVENT_HEADER_LEN;
3874
 
  if (!(mem_pool = (char*) my_malloc(event_len + 1, MYF(MY_WME))))
3875
 
    return;
3876
 
  memcpy(mem_pool, buf + LOG_EVENT_HEADER_LEN, event_len);
3877
 
  mem_pool[event_len] = 0;
3878
 
  init_from_mem_pool(event_len);
 
3846
#ifdef FIXME
 
3847
  /* Assign these correctly */
 
3848
  master_host.assign(mem_pool + SL_MASTER_HOST_OFFSET);
 
3849
  master_log.assign();
 
3850
#endif
3879
3851
}
3880
3852
 
3881
3853