Beispiel #1
0
  def start_vttablet(self, port=None, auth=False, memcache=False, wait_for_state="SERVING", customrules=None, schema_override=None, cert=None, key=None, ca_cert=None, repl_extra_flags={}):
    """
    Starts a vttablet process, and returns it.
    The process is also saved in self.proc, so it's easy to kill as well.
    """
    environment.prog_compile('vtaction')
    args = [environment.binary_path('vttablet'),
            '-port', '%s' % (port or self.port),
            '-tablet-path', self.tablet_alias,
            '-log_dir', environment.vtlogroot]
    args.extend(environment.topo_server_flags())
    args.extend(environment.binlog_player_protocol_flags())

    dbconfigs = self._get_db_configs_file(repl_extra_flags)
    for key1 in dbconfigs:
      for key2 in dbconfigs[key1]:
        args.extend(["-db-config-"+key1+"-"+key2, dbconfigs[key1][key2]])

    if memcache:
      if os.path.exists(environment.vtroot + "/bin/memcached"):
        args.extend(["-rowcache-bin", environment.vtroot + "/bin/memcached"])
      else:
        args.extend(["-rowcache-bin", "memcached"])
      memcache_socket = os.path.join(self.tablet_dir, "memcache.sock")
      args.extend(["-rowcache-socket", memcache_socket])
      args.extend(["-enable-rowcache"])

    if auth:
      args.extend(['-auth-credentials', os.path.join(environment.vttop, 'test', 'test_data', 'authcredentials_test.json')])

    if customrules:
      args.extend(['-customrules', customrules])

    if schema_override:
      args.extend(['-schema-override', schema_override])

    if cert:
      self.secure_port = environment.reserve_ports(1)
      args.extend(['-secure-port', '%s' % self.secure_port,
                   '-cert', cert,
                   '-key', key])
      if ca_cert:
        args.extend(['-ca-cert', ca_cert])

    stderr_fd = open(os.path.join(self.tablet_dir, "vttablet.stderr"), "w")
    # increment count only the first time
    if not self.proc:
      Tablet.tablets_running += 1
    self.proc = utils.run_bg(args, stderr=stderr_fd)
    stderr_fd.close()

    # wait for zookeeper PID just to be sure we have it
    if environment.topo_server_implementation == 'zookeeper':
      utils.run(environment.binary_path('zk')+' wait -e ' + self.zk_pid, stdout=utils.devnull)

    # wait for query service to be in the right state
    if wait_for_state:
      self.wait_for_vttablet_state(wait_for_state, port=port)

    return self.proc
Beispiel #2
0
  def start_vttablet(self, port=None, auth=False, memcache=False, wait_for_state="SERVING", customrules=None, schema_override=None, cert=None, key=None, ca_cert=None, repl_extra_flags={}):
    """
    Starts a vttablet process, and returns it.
    The process is also saved in self.proc, so it's easy to kill as well.
    """
    environment.prog_compile('vtaction')
    args = [environment.binary_path('vttablet'),
            '-port', '%s' % (port or self.port),
            '-tablet-path', self.tablet_alias,
            '-log_dir', environment.vtlogroot]
    args.extend(environment.topo_server_flags())
    args.extend(utils.binlog_player_protocol_flags)

    dbconfigs = self._get_db_configs_file(repl_extra_flags)
    for key1 in dbconfigs:
      for key2 in dbconfigs[key1]:
        args.extend(["-db-config-"+key1+"-"+key2, dbconfigs[key1][key2]])

    if memcache:
      if os.path.exists(environment.vtroot + "/bin/memcached"):
        args.extend(["-rowcache-bin", environment.vtroot + "/bin/memcached"])
      else:
        args.extend(["-rowcache-bin", "memcached"])
      memcache_socket = os.path.join(self.tablet_dir, "memcache.sock")
      args.extend(["-rowcache-socket", memcache_socket])
      args.extend(["-enable-rowcache"])

    if auth:
      args.extend(['-auth-credentials', os.path.join(environment.vttop, 'test', 'test_data', 'authcredentials_test.json')])

    if customrules:
      args.extend(['-customrules', customrules])

    if schema_override:
      args.extend(['-schema-override', schema_override])

    if cert:
      self.secure_port = environment.reserve_ports(1)
      args.extend(['-secure-port', '%s' % self.secure_port,
                   '-cert', cert,
                   '-key', key])
      if ca_cert:
        args.extend(['-ca-cert', ca_cert])

    stderr_fd = open(os.path.join(self.tablet_dir, "vttablet.stderr"), "w")
    # increment count only the first time
    if not self.proc:
      Tablet.tablets_running += 1
    self.proc = utils.run_bg(args, stderr=stderr_fd)
    stderr_fd.close()

    # wait for zookeeper PID just to be sure we have it
    if environment.topo_server_implementation == 'zookeeper':
      utils.run(environment.binary_path('zk')+' wait -e ' + self.zk_pid, stdout=utils.devnull)

    # wait for query service to be in the right state
    if wait_for_state:
      self.wait_for_vttablet_state(wait_for_state, port=port)

    return self.proc
Beispiel #3
0
    def start(self):
        args = environment.binary_args('vtctld') + [
                '-debug',
                '-templates', environment.vttop + '/go/cmd/vtctld/templates',
                '-log_dir', environment.vtlogroot,
                '-port', str(self.port),
                ] + \
                environment.topo_server_flags() + \
                environment.tablet_manager_protocol_flags()
        stderr_fd = open(os.path.join(environment.tmproot, "vtctld.stderr"),
                         "w")
        self.proc = run_bg(args, stderr=stderr_fd)

        # wait for the process to listen to RPC
        timeout = 30
        while True:
            v = get_vars(self.port)
            if v:
                break
            timeout = wait_step('waiting for vtctld to start',
                                timeout,
                                sleep_time=0.2)

        # save the running instance so vtctl commands can be remote executed now
        global vtctld, vtctld_connection
        if not vtctld:
            vtctld = self
            vtctld_connection = vtctl_client.connect(
                environment.vtctl_client_protocol(),
                'localhost:%u' % self.port, 30)

        return self.proc
Beispiel #4
0
def run_vtworker(clargs,
                 log_level='',
                 auto_log=False,
                 expect_fail=False,
                 **kwargs):
    args = environment.binary_args('vtworker') + [
        '-log_dir', environment.vtlogroot, '-port',
        str(environment.reserve_ports(1))
    ]
    args.extend(environment.topo_server_flags())
    args.extend(environment.tablet_manager_protocol_flags())

    if auto_log:
        if options.verbose == 2:
            log_level = 'INFO'
        elif options.verbose == 1:
            log_level = 'WARNING'
        else:
            log_level = 'ERROR'
    if log_level:
        args.append('--stderrthreshold=%s' % log_level)

    cmd = args + clargs
    if expect_fail:
        return run_fail(cmd, **kwargs)
    return run(cmd, **kwargs)
Beispiel #5
0
def vtgate_start(vtport=None, cell='test_nj', retry_delay=1, retry_count=1, topo_impl=None, tablet_bson_encrypted=False, cache_ttl='1s', auth=False, timeout="5s", cert=None, key=None, ca_cert=None):
  port = vtport or environment.reserve_ports(1)
  secure_port = None
  args = [environment.binary_path('vtgate'),
          '-port', str(port),
          '-cell', cell,
          '-retry-delay', '%ss' % (str(retry_delay)),
          '-retry-count', str(retry_count),
          '-log_dir', environment.vtlogroot,
          '-srv_topo_cache_ttl', cache_ttl,
          '-timeout', timeout,
          ] + environment.tabletconn_protocol_flags()
  if topo_impl:
    args.extend(['-topo_implementation', topo_impl])
  else:
    args.extend(environment.topo_server_flags())
  if tablet_bson_encrypted:
    args.append('-tablet-bson-encrypted')
  if auth:
    args.extend(['-auth-credentials', os.path.join(environment.vttop, 'test', 'test_data', 'authcredentials_test.json')])
  if cert:
    secure_port = environment.reserve_ports(1)
    args.extend(['-secure-port', '%s' % secure_port,
                 '-cert', cert,
                 '-key', key])
    if ca_cert:
      args.extend(['-ca-cert', ca_cert])

  sp = run_bg(args)
  if cert:
    wait_for_vars("vtgate", port, "SecureConnections")
    return sp, port, secure_port
  else:
    wait_for_vars("vtgate", port)
    return sp, port
Beispiel #6
0
def vtclient2(uid, path, query, bindvars=None, user=None, password=None, driver=None,
              verbose=False, raise_on_error=True):
  if (user is None) != (password is None):
    raise TypeError("you should provide either both or none of user and password")

  # for ZK paths to not have // in the path, that confuses things
  if path.startswith('/'):
    path = path[1:]
  server = "localhost:%u/%s" % (uid, path)

  cmdline = [environment.binary_path('vtclient2'), '-server', server]
  cmdline += environment.topo_server_flags()
  cmdline += environment.tabletconn_protocol_flags()
  if user is not None:
    cmdline.extend(['-tablet-bson-username', user,
                    '-tablet-bson-password', password])
  if bindvars:
    cmdline.extend(['-bindvars', bindvars])
  if driver:
    cmdline.extend(['-driver', driver])
  if verbose:
    cmdline.extend(['-alsologtostderr', '-verbose'])
  cmdline.append(query)

  return run(cmdline, raise_on_error=raise_on_error, trap_output=True)
Beispiel #7
0
    def test_sigterm(self):
        utils.run_vtctl('CreateKeyspace test_keyspace')

        # create the database so vttablets start, as it is serving
        tablet_62344.create_db('vt_test_keyspace')

        tablet_62344.init_tablet('master', 'test_keyspace', '0', start=True)

        # start a 'vtctl Sleep' command in the background
        args = [
            environment.binary_path('vtctl'), '-log_dir',
            environment.vtlogroot, '--alsologtostderr'
        ]
        args.extend(environment.topo_server_flags())
        args.extend(environment.tablet_manager_protocol_flags())
        args.extend(['Sleep', tablet_62344.tablet_alias, '60s'])
        sp = utils.run_bg(args, stdout=PIPE, stderr=PIPE)

        # wait for it to start, and let's kill it
        time.sleep(4.0)
        utils.run(['pkill', 'vtaction'])
        out, err = sp.communicate()

        # check the vtctl command got the right remote error back
        if "vtaction interrupted by signal" not in err:
            self.fail("cannot find expected output in error: " + err)
        logging.debug("vtaction was interrupted correctly:\n" + err)

        tablet_62344.kill_vttablet()
Beispiel #8
0
def run_vtctl(clargs, log_level='', auto_log=False, expect_fail=False, **kwargs):
  args = environment.binary_args('vtctl') + ['-log_dir', environment.vtlogroot]
  args.extend(environment.topo_server_flags())
  args.extend(environment.tablet_manager_protocol_flags())
  args.extend(environment.tabletconn_protocol_flags())

  if auto_log:
    if options.verbose == 2:
      log_level='INFO'
    elif options.verbose == 1:
      log_level='WARNING'
    else:
      log_level='ERROR'

  if log_level:
    args.append('--stderrthreshold=%s' % log_level)

  if isinstance(clargs, str):
    cmd = " ".join(args) + ' ' + clargs
  else:
    cmd = args + clargs

  if expect_fail:
    return run_fail(cmd, **kwargs)
  return run(cmd, **kwargs)
Beispiel #9
0
def run_vtctl(clargs, log_level='', auto_log=False, expect_fail=False, **kwargs):
  args = [environment.binary_path('vtctl'), '-log_dir', environment.vtlogroot]
  args.extend(environment.topo_server_flags())
  args.extend(environment.tablet_manager_protocol_flags())
  args.extend(environment.tabletconn_protocol_flags())

  if auto_log:
    if options.verbose == 2:
      log_level='INFO'
    elif options.verbose == 1:
      log_level='WARNING'
    else:
      log_level='ERROR'

  if log_level:
    args.append('--stderrthreshold=%s' % log_level)

  if isinstance(clargs, str):
    cmd = " ".join(args) + ' ' + clargs
  else:
    cmd = args + clargs

  if expect_fail:
    return run_fail(cmd, **kwargs)
  return run(cmd, **kwargs)
Beispiel #10
0
def vtclient2(uid, path, query, bindvars=None, user=None, password=None, driver=None,
              verbose=False, raise_on_error=True):
  if (user is None) != (password is None):
    raise TypeError("you should provide either both or none of user and password")

  # for ZK paths to not have // in the path, that confuses things
  if path.startswith('/'):
    path = path[1:]
  server = "localhost:%u/%s" % (uid, path)

  cmdline = environment.binary_args('vtclient2') + ['-server', server]
  cmdline += environment.topo_server_flags()
  cmdline += environment.tabletconn_protocol_flags()
  if user is not None:
    cmdline.extend(['-tablet-bson-username', user,
                    '-tablet-bson-password', password])
  if bindvars:
    cmdline.extend(['-bindvars', bindvars])
  if driver:
    cmdline.extend(['-driver', driver])
  if verbose:
    cmdline.extend(['-alsologtostderr', '-verbose'])
  cmdline.append(query)

  return run(cmdline, raise_on_error=raise_on_error, trap_output=True)
Beispiel #11
0
  def start(self):
    args = environment.binary_args('vtctld') + [
            '-debug',
            '-templates', environment.vttop + '/go/cmd/vtctld/templates',
            '-log_dir', environment.vtlogroot,
            '-port', str(self.port),
            ] + \
            environment.topo_server_flags() + \
            environment.tablet_manager_protocol_flags()
    stderr_fd = open(os.path.join(environment.tmproot, "vtctld.stderr"), "w")
    self.proc = run_bg(args, stderr=stderr_fd)

    # wait for the process to listen to RPC
    timeout = 30
    while True:
      v = get_vars(self.port)
      if v:
        break
      timeout = wait_step('waiting for vtctld to start', timeout,
                          sleep_time=0.2)

    # save the running instance so vtctl commands can be remote executed now
    global vtctld, vtctld_connection
    if not vtctld:
      vtctld = self
      vtctld_connection = vtctl_client.connect(
          environment.vtctl_client_protocol(), 'localhost:%u' % self.port, 30)

    return self.proc
Beispiel #12
0
  def test_sigterm(self):
    utils.run_vtctl('CreateKeyspace test_keyspace')

    # create the database so vttablets start, as it is serving
    tablet_62344.create_db('vt_test_keyspace')

    tablet_62344.init_tablet('master', 'test_keyspace', '0', start=True)

    # start a 'vtctl Sleep' command in the background
    args = [environment.binary_path('vtctl'),
            '-log_dir', environment.vtlogroot,
            '--alsologtostderr']
    args.extend(environment.topo_server_flags())
    args.extend(environment.tablet_manager_protocol_flags())
    args.extend(['Sleep', tablet_62344.tablet_alias, '60s'])
    sp = utils.run_bg(args, stdout=PIPE, stderr=PIPE)

    # wait for it to start, and let's kill it
    time.sleep(4.0)
    utils.run(['pkill', 'vtaction'])
    out, err = sp.communicate()

    # check the vtctl command got the right remote error back
    if "vtaction interrupted by signal" not in err:
      self.fail("cannot find expected output in error: " + err)
    logging.debug("vtaction was interrupted correctly:\n" + err)

    tablet_62344.kill_vttablet()
Beispiel #13
0
  def test_actions_and_timeouts(self):
    # Start up a master mysql and vttablet
    utils.run_vtctl(['CreateKeyspace', 'test_keyspace'])

    tablet_62344.init_tablet('master', 'test_keyspace', '0')
    utils.run_vtctl(['RebuildShardGraph', 'test_keyspace/0'])
    utils.validate_topology()
    srvShard = utils.run_vtctl_json(['GetSrvShard', 'test_nj',
                                     'test_keyspace/0'])
    self.assertEqual(srvShard['MasterCell'], 'test_nj')
    tablet_62344.create_db('vt_test_keyspace')
    tablet_62344.start_vttablet()

    utils.run_vtctl(['RpcPing', tablet_62344.tablet_alias])

    # schedule long action in the background, sleep a little bit to make sure
    # it started to run
    args = (environment.binary_args('vtctl') +
            environment.topo_server_flags() +
            environment.tablet_manager_protocol_flags() +
            environment.tabletconn_protocol_flags() +
            ['-log_dir', environment.vtlogroot,
             'Sleep', tablet_62344.tablet_alias, '10s'])
    bg = utils.run_bg(args)
    time.sleep(3)

    # try a frontend RpcPing that should timeout as the tablet is busy
    # running the other one
    stdout, stderr = utils.run_vtctl(['-wait-time', '3s',
                                      'RpcPing', tablet_62344.tablet_alias],
                                     expect_fail=True)
    if 'Timeout waiting for' not in stderr:
      self.fail("didn't find the right error strings in failed RpcPing: " +
                stderr)

    # wait for the background vtctl
    bg.wait()

    if environment.topo_server_implementation == 'zookeeper':
      # extra small test: we ran for a while, get the states we were in,
      # make sure they're accounted for properly
      # first the query engine States
      v = utils.get_vars(tablet_62344.port)
      logging.debug("vars: %s" % str(v))

      # then the Zookeeper connections
      if v['ZkMetaConn']['test_nj']['Current'] != 'Connected':
        self.fail('invalid zk test_nj state: %s' %
                  v['ZkMetaConn']['test_nj']['Current'])
      if v['ZkMetaConn']['global']['Current'] != 'Connected':
        self.fail('invalid zk global state: %s' %
                  v['ZkMetaConn']['global']['Current'])
      if v['ZkMetaConn']['test_nj']['DurationConnected'] < 10e9:
        self.fail('not enough time in Connected state: %u',
                  v['ZkMetaConn']['test_nj']['DurationConnected'])
      if v['TabletType'] != 'master':
        self.fail('TabletType not exported correctly')

    tablet_62344.kill_vttablet()
Beispiel #14
0
    def test_actions_and_timeouts(self):
        # Start up a master mysql and vttablet
        utils.run_vtctl(['CreateKeyspace', 'test_keyspace'])

        tablet_62344.init_tablet('master', 'test_keyspace', '0')
        utils.run_vtctl(['RebuildShardGraph', 'test_keyspace/0'])
        utils.validate_topology()
        srvShard = utils.run_vtctl_json(
            ['GetSrvShard', 'test_nj', 'test_keyspace/0'])
        self.assertEqual(srvShard['MasterCell'], 'test_nj')
        tablet_62344.create_db('vt_test_keyspace')
        tablet_62344.start_vttablet()

        utils.run_vtctl(['Ping', tablet_62344.tablet_alias])

        # schedule long action in the background, sleep a little bit to make sure
        # it started to run
        args = (environment.binary_args('vtctl') +
                environment.topo_server_flags() +
                environment.tablet_manager_protocol_flags() +
                environment.tabletconn_protocol_flags() + [
                    '-log_dir', environment.vtlogroot, 'Sleep',
                    tablet_62344.tablet_alias, '10s'
                ])
        bg = utils.run_bg(args)
        time.sleep(3)

        # try a frontend RefreshState that should timeout as the tablet is busy
        # running the other one
        stdout, stderr = utils.run_vtctl(
            ['-wait-time', '3s', 'RefreshState', tablet_62344.tablet_alias],
            expect_fail=True)
        self.assertIn(environment.rpc_timeout_message, stderr)

        # wait for the background vtctl
        bg.wait()

        if environment.topo_server_implementation == 'zookeeper':
            # extra small test: we ran for a while, get the states we were in,
            # make sure they're accounted for properly
            # first the query engine States
            v = utils.get_vars(tablet_62344.port)
            logging.debug("vars: %s" % str(v))

            # then the Zookeeper connections
            if v['ZkMetaConn']['test_nj']['Current'] != 'Connected':
                self.fail('invalid zk test_nj state: %s' %
                          v['ZkMetaConn']['test_nj']['Current'])
            if v['ZkMetaConn']['global']['Current'] != 'Connected':
                self.fail('invalid zk global state: %s' %
                          v['ZkMetaConn']['global']['Current'])
            if v['ZkMetaConn']['test_nj']['DurationConnected'] < 10e9:
                self.fail('not enough time in Connected state: %u',
                          v['ZkMetaConn']['test_nj']['DurationConnected'])
            if v['TabletType'] != 'master':
                self.fail('TabletType not exported correctly')

        tablet_62344.kill_vttablet()
Beispiel #15
0
def vtgate_start(vtport=None,
                 cell='test_nj',
                 retry_delay=1,
                 retry_count=1,
                 topo_impl=None,
                 tablet_bson_encrypted=False,
                 cache_ttl='1s',
                 auth=False,
                 timeout="5s",
                 cert=None,
                 key=None,
                 ca_cert=None):
    port = vtport or environment.reserve_ports(1)
    secure_port = None
    args = [
        environment.binary_path('vtgate'),
        '-port',
        str(port),
        '-cell',
        cell,
        '-retry-delay',
        '%ss' % (str(retry_delay)),
        '-retry-count',
        str(retry_count),
        '-log_dir',
        environment.vtlogroot,
        '-srv_topo_cache_ttl',
        cache_ttl,
        '-timeout',
        timeout,
    ] + environment.tabletconn_protocol_flags()
    if topo_impl:
        args.extend(['-topo_implementation', topo_impl])
    else:
        args.extend(environment.topo_server_flags())
    if tablet_bson_encrypted:
        args.append('-tablet-bson-encrypted')
    if auth:
        args.extend([
            '-auth-credentials',
            os.path.join(environment.vttop, 'test', 'test_data',
                         'authcredentials_test.json')
        ])
    if cert:
        secure_port = environment.reserve_ports(1)
        args.extend(
            ['-secure-port',
             '%s' % secure_port, '-cert', cert, '-key', key])
        if ca_cert:
            args.extend(['-ca-cert', ca_cert])

    sp = run_bg(args)
    if cert:
        wait_for_vars("vtgate", port, "SecureConnections")
        return sp, port, secure_port
    else:
        wait_for_vars("vtgate", port)
        return sp, port
Beispiel #16
0
 def start(self):
   args = [environment.binary_path('vtctld'),
           '-debug',
           '-templates', environment.vttop + '/go/cmd/vtctld/templates',
           '-log_dir', environment.vtlogroot,
           '-port', str(self.port),
           ] + \
           environment.topo_server_flags() + \
           environment.tablet_manager_protocol_flags()
   stderr_fd = open(os.path.join(environment.tmproot, "vtctld.stderr"), "w")
   self.proc = utils.run_bg(args, stderr=stderr_fd)
   return self.proc
Beispiel #17
0
 def start(self):
     args = environment.binary_args('vtctld') + [
             '-debug',
             '-templates', environment.vttop + '/go/cmd/vtctld/templates',
             '-log_dir', environment.vtlogroot,
             '-port', str(self.port),
             ] + \
             environment.topo_server_flags() + \
             environment.tablet_manager_protocol_flags()
     stderr_fd = open(os.path.join(environment.tmproot, "vtctld.stderr"),
                      "w")
     self.proc = utils.run_bg(args, stderr=stderr_fd)
     return self.proc
Beispiel #18
0
def vtgate_start(cell='test_nj', retry_delay=1, retry_count=1, topo_impl=None, tablet_bson_encrypted=False):
  port = environment.reserve_ports(1)
  args = [environment.binary_path('vtgate'),
          '-port', str(port),
          '-cell', cell,
          '-retry-delay', '%ss' % (str(retry_delay)),
          '-retry-count', str(retry_count),
          '-log_dir', environment.vtlogroot,
          ] + environment.vtgate_protocol_flags()
  if topo_impl:
    args.extend(['-topo_implementation', topo_impl])
  else:
    args.extend(environment.topo_server_flags())
  if tablet_bson_encrypted:
    args.append('-tablet-bson-encrypted')
  sp = run_bg(args)
  wait_for_vars("vtgate", port)
  return sp, port
Beispiel #19
0
def run_vtworker(clargs, log_level='', auto_log=False, expect_fail=False, **kwargs):
  args = environment.binary_args('vtworker') + [
          '-log_dir', environment.vtlogroot,
          '-port', str(environment.reserve_ports(1))]
  args.extend(environment.topo_server_flags())
  args.extend(environment.tablet_manager_protocol_flags())

  if auto_log:
    if options.verbose == 2:
      log_level='INFO'
    elif options.verbose == 1:
      log_level='WARNING'
    else:
      log_level='ERROR'
  if log_level:
    args.append('--stderrthreshold=%s' % log_level)

  cmd = args + clargs
  if expect_fail:
    return run_fail(cmd, **kwargs)
  return run(cmd, **kwargs)
Beispiel #20
0
  def start_vttablet(self, port=None, auth=False, memcache=False,
                     wait_for_state="SERVING", customrules=None,
                     schema_override=None, cert=None, key=None, ca_cert=None,
                     repl_extra_flags={}, sensitive_mode=False,
                     target_tablet_type=None, lameduck_period=None,
                     extra_args=None, full_mycnf_args=False,
                     security_policy=None):
    """
    Starts a vttablet process, and returns it.
    The process is also saved in self.proc, so it's easy to kill as well.
    """
    environment.prog_compile('vtaction')
    args = [environment.binary_path('vttablet'),
            '-port', '%s' % (port or self.port),
            '-tablet-path', self.tablet_alias,
            '-log_dir', environment.vtlogroot]
    args.extend(environment.topo_server_flags())
    args.extend(utils.binlog_player_protocol_flags)

    dbconfigs = self._get_db_configs_file(repl_extra_flags)
    for key1 in dbconfigs:
      for key2 in dbconfigs[key1]:
        args.extend(["-db-config-"+key1+"-"+key2, dbconfigs[key1][key2]])

    if full_mycnf_args:
      # this flag is used to specify all the mycnf_ flags, to make
      # sure that code works and can fork actions.
      relay_log_path = os.path.join(self.tablet_dir, "relay-logs",
                                    "vt-%010d-relay-bin" % self.tablet_uid)
      args.extend([
          "-mycnf_server_id", str(self.tablet_uid),
          "-mycnf_mysql_port", str(self.mysql_port),
          "-mycnf_data_dir", os.path.join(self.tablet_dir, "data"),
          "-mycnf_innodb_data_home_dir", os.path.join(self.tablet_dir,
                                                      "innodb", "data"),
          "-mycnf_innodb_log_group_home_dir", os.path.join(self.tablet_dir,
                                                           "innodb", "logs"),
          "-mycnf_socket_file", os.path.join(self.tablet_dir, "mysql.sock"),
          "-mycnf_error_log_path", os.path.join(self.tablet_dir, "error.log"),
          "-mycnf_slow_log_path", os.path.join(self.tablet_dir,
                                               "slow-query.log"),
          "-mycnf_relay_log_path", relay_log_path,
          "-mycnf_relay_log_index_path", relay_log_path + ".index",
          "-mycnf_relay_log_info_path", os.path.join(self.tablet_dir,
                                                     "relay-logs",
                                                     "relay-log.info"),
          "-mycnf_bin_log_path", os.path.join(self.tablet_dir, "bin-logs",
                                              "vt-%010d-bin" % self.tablet_uid),
          "-mycnf_master_info_file", os.path.join(self.tablet_dir,
                                                  "master.info"),
          "-mycnf_pid_file", os.path.join(self.tablet_dir, "mysql.pid"),
          "-mycnf_tmp_dir", os.path.join(self.tablet_dir, "tmp"),
          "-mycnf_slave_load_tmp_dir", os.path.join(self.tablet_dir, "tmp"),
          ])

    if memcache:
      args.extend(["-rowcache-bin", environment.memcached_bin()])
      memcache_socket = os.path.join(self.tablet_dir, "memcache.sock")
      args.extend(["-rowcache-socket", memcache_socket])
      args.extend(["-enable-rowcache"])

    if auth:
      args.extend(['-auth-credentials', os.path.join(environment.vttop, 'test', 'test_data', 'authcredentials_test.json')])

    if customrules:
      args.extend(['-customrules', customrules])

    if schema_override:
      args.extend(['-schema-override', schema_override])

    if cert:
      self.secure_port = environment.reserve_ports(1)
      args.extend(['-secure-port', '%s' % self.secure_port,
                   '-cert', cert,
                   '-key', key])
      if ca_cert:
        args.extend(['-ca_cert', ca_cert])
    if sensitive_mode:
      args.extend(['-queryserver-config-sensitive-mode'])
    if target_tablet_type:
      args.extend(['-target_tablet_type', target_tablet_type,
                   '-health_check_interval', '2s',
                   '-allowed_replication_lag', '30'])
    if lameduck_period:
      args.extend(['-lameduck-period', lameduck_period])
    if extra_args:
      args.extend(extra_args)
    if security_policy:
      args.extend(['-security_policy', security_policy])

    stderr_fd = open(os.path.join(self.tablet_dir, "vttablet.stderr"), "w")
    # increment count only the first time
    if not self.proc:
      Tablet.tablets_running += 1
    self.proc = utils.run_bg(args, stderr=stderr_fd)
    stderr_fd.close()

    # wait for zookeeper PID just to be sure we have it
    if environment.topo_server_implementation == 'zookeeper':
      utils.run(environment.binary_path('zk')+' wait -e ' + self.zk_pid, stdout=utils.devnull)

    # wait for query service to be in the right state
    if wait_for_state:
      self.wait_for_vttablet_state(wait_for_state, port=port)

    return self.proc
Beispiel #21
0
  def test_reparent_down_master(self):
    utils.run_vtctl('CreateKeyspace test_keyspace')

    # create the database so vttablets start, as they are serving
    tablet_62344.create_db('vt_test_keyspace')
    tablet_62044.create_db('vt_test_keyspace')
    tablet_41983.create_db('vt_test_keyspace')
    tablet_31981.create_db('vt_test_keyspace')

    # Start up a master mysql and vttablet
    tablet_62344.init_tablet('master', 'test_keyspace', '0', start=True, wait_for_start=False)

    # Create a few slaves for testing reparenting.
    tablet_62044.init_tablet('replica', 'test_keyspace', '0', start=True, wait_for_start=False)
    tablet_41983.init_tablet('replica', 'test_keyspace', '0', start=True, wait_for_start=False)
    tablet_31981.init_tablet('replica', 'test_keyspace', '0', start=True, wait_for_start=False)

    # wait for all tablets to start
    for t in [tablet_62344, tablet_62044, tablet_41983, tablet_31981]:
      t.wait_for_vttablet_state("SERVING")

    # Recompute the shard layout node - until you do that, it might not be valid.
    utils.run_vtctl('RebuildShardGraph test_keyspace/0')
    utils.validate_topology()

    # Force the slaves to reparent assuming that all the datasets are identical.
    for t in [tablet_62344, tablet_62044, tablet_41983, tablet_31981]:
      t.reset_replication()
    utils.run_vtctl('ReparentShard -force test_keyspace/0 ' + tablet_62344.tablet_alias, auto_log=True)
    utils.validate_topology()

    # Make the master agent and database unavailable.
    tablet_62344.kill_vttablet()
    tablet_62344.shutdown_mysql().wait()

    self._check_db_addr('0', 'master', tablet_62344.port)

    # Perform a reparent operation - the Validate part will try to ping
    # the master and fail somewhat quickly
    stdout, stderr = utils.run_vtctl('-wait-time 5s ReparentShard test_keyspace/0 ' + tablet_62044.tablet_alias, expect_fail=True)
    logging.debug("Failed ReparentShard output:\n" + stderr)
    if 'ValidateShard verification failed' not in stderr:
      self.fail("didn't find the right error strings in failed ReparentShard: " + stderr)

    # Should timeout and fail
    stdout, stderr = utils.run_vtctl('-wait-time 5s ScrapTablet ' + tablet_62344.tablet_alias, expect_fail=True)
    logging.debug("Failed ScrapTablet output:\n" + stderr)
    if 'deadline exceeded' not in stderr:
      self.fail("didn't find the right error strings in failed ScrapTablet: " + stderr)

    # Should interrupt and fail
    args = [environment.binary_path('vtctl'),
            '-log_dir', environment.vtlogroot,
            '-wait-time', '10s']
    args.extend(environment.topo_server_flags())
    args.extend(environment.tablet_manager_protocol_flags())
    args.extend(['ScrapTablet', tablet_62344.tablet_alias])
    sp = utils.run_bg(args, stdout=PIPE, stderr=PIPE)
    # Need time for the process to start before killing it.
    time.sleep(3.0)
    os.kill(sp.pid, signal.SIGINT)
    stdout, stderr = sp.communicate()

    logging.debug("Failed ScrapTablet output:\n" + stderr)
    if 'interrupted' not in stderr:
      self.fail("didn't find the right error strings in failed ScrapTablet: " + stderr)

    # Force the scrap action in zk even though tablet is not accessible.
    tablet_62344.scrap(force=True)

    utils.run_vtctl('ChangeSlaveType -force %s idle' %
                    tablet_62344.tablet_alias, expect_fail=True)

    # Remove pending locks (make this the force option to ReparentShard?)
    if environment.topo_server_implementation == 'zookeeper':
      utils.run_vtctl('PurgeActions /zk/global/vt/keyspaces/test_keyspace/shards/0/action')

    # Re-run reparent operation, this shoud now proceed unimpeded.
    utils.run_vtctl('-wait-time 1m ReparentShard test_keyspace/0 ' + tablet_62044.tablet_alias, auto_log=True)

    utils.validate_topology()
    self._check_db_addr('0', 'master', tablet_62044.port)

    utils.run_vtctl(['ChangeSlaveType', '-force', tablet_62344.tablet_alias, 'idle'])

    idle_tablets, _ = utils.run_vtctl('ListAllTablets test_nj', trap_output=True)
    if '0000062344 <null> <null> idle' not in idle_tablets:
      self.fail('idle tablet not found: %s' % idle_tablets)

    tablet.kill_tablets([tablet_62044, tablet_41983, tablet_31981])

    # so the other tests don't have any surprise
    tablet_62344.start_mysql().wait()
Beispiel #22
0
  def start_vttablet(self, port=None, auth=False, memcache=False,
                     wait_for_state='SERVING', customrules=None,
                     schema_override=None, cert=None, key=None, ca_cert=None,
                     repl_extra_flags={}, table_acl_config=None,
                     lameduck_period=None, security_policy=None,
                     target_tablet_type=None, full_mycnf_args=False,
                     extra_args=None, extra_env=None, include_mysql_port=True):
    """Starts a vttablet process, and returns it.

    The process is also saved in self.proc, so it's easy to kill as well.
    """
    args = []
    args.extend(['-tablet-path', self.tablet_alias])
    args.extend(environment.topo_server_flags())
    args.extend(utils.binlog_player_protocol_flags)
    args.extend(environment.tablet_manager_protocol_flags())
    args.extend(['-pid_file', os.path.join(self.tablet_dir, 'vttablet.pid')])
    if self.use_mysqlctld:
      args.extend(['-mysqlctl_socket', os.path.join(self.tablet_dir, 'mysqlctl.sock')])

    if full_mycnf_args:
      # this flag is used to specify all the mycnf_ flags, to make
      # sure that code works and can fork actions.
      relay_log_path = os.path.join(self.tablet_dir, 'relay-logs',
                                    'vt-%010d-relay-bin' % self.tablet_uid)
      args.extend([
          '-mycnf_server_id', str(self.tablet_uid),
          '-mycnf_data_dir', os.path.join(self.tablet_dir, 'data'),
          '-mycnf_innodb_data_home_dir', os.path.join(self.tablet_dir,
                                                      'innodb', 'data'),
          '-mycnf_innodb_log_group_home_dir', os.path.join(self.tablet_dir,
                                                           'innodb', 'logs'),
          '-mycnf_socket_file', os.path.join(self.tablet_dir, 'mysql.sock'),
          '-mycnf_error_log_path', os.path.join(self.tablet_dir, 'error.log'),
          '-mycnf_slow_log_path', os.path.join(self.tablet_dir,
                                               'slow-query.log'),
          '-mycnf_relay_log_path', relay_log_path,
          '-mycnf_relay_log_index_path', relay_log_path + '.index',
          '-mycnf_relay_log_info_path', os.path.join(self.tablet_dir,
                                                     'relay-logs',
                                                     'relay-log.info'),
          '-mycnf_bin_log_path', os.path.join(self.tablet_dir, 'bin-logs',
                                              'vt-%010d-bin' % self.tablet_uid),
          '-mycnf_master_info_file', os.path.join(self.tablet_dir,
                                                  'master.info'),
          '-mycnf_pid_file', os.path.join(self.tablet_dir, 'mysql.pid'),
          '-mycnf_tmp_dir', os.path.join(self.tablet_dir, 'tmp'),
          '-mycnf_slave_load_tmp_dir', os.path.join(self.tablet_dir, 'tmp'),
      ])
      if include_mysql_port:
        args.extend(['-mycnf_mysql_port', str(self.mysql_port)])
    if target_tablet_type:
      args.extend(['-target_tablet_type', target_tablet_type,
                   '-health_check_interval', '2s',
                   '-allowed_replication_lag', '30'])

    if extra_args:
      args.extend(extra_args)

    return self._start_prog(binary='vttablet', port=port, auth=auth,
                            memcache=memcache, wait_for_state=wait_for_state,
                            customrules=customrules,
                            schema_override=schema_override,
                            cert=cert, key=key, ca_cert=ca_cert,
                            repl_extra_flags=repl_extra_flags,
                            table_acl_config=table_acl_config,
                            lameduck_period=lameduck_period, extra_args=args,
                            security_policy=security_policy, extra_env=extra_env)
Beispiel #23
0
    def start_vttablet(self,
                       port=None,
                       auth=False,
                       memcache=False,
                       wait_for_state="SERVING",
                       customrules=None,
                       schema_override=None,
                       cert=None,
                       key=None,
                       ca_cert=None,
                       repl_extra_flags={},
                       sensitive_mode=False,
                       target_tablet_type=None,
                       lameduck_period=None,
                       extra_args=None,
                       full_mycnf_args=False,
                       security_policy=None):
        """
    Starts a vttablet process, and returns it.
    The process is also saved in self.proc, so it's easy to kill as well.
    """
        environment.prog_compile('vtaction')
        args = [
            environment.binary_path('vttablet'), '-port',
            '%s' % (port or self.port), '-tablet-path', self.tablet_alias,
            '-log_dir', environment.vtlogroot
        ]
        args.extend(environment.topo_server_flags())
        args.extend(utils.binlog_player_protocol_flags)

        dbconfigs = self._get_db_configs_file(repl_extra_flags)
        for key1 in dbconfigs:
            for key2 in dbconfigs[key1]:
                args.extend(
                    ["-db-config-" + key1 + "-" + key2, dbconfigs[key1][key2]])

        if full_mycnf_args:
            # this flag is used to specify all the mycnf_ flags, to make
            # sure that code works and can fork actions.
            relay_log_path = os.path.join(
                self.tablet_dir, "relay-logs",
                "vt-%010d-relay-bin" % self.tablet_uid)
            args.extend([
                "-mycnf_server_id",
                str(self.tablet_uid),
                "-mycnf_mysql_port",
                str(self.mysql_port),
                "-mycnf_data_dir",
                os.path.join(self.tablet_dir, "data"),
                "-mycnf_innodb_data_home_dir",
                os.path.join(self.tablet_dir, "innodb", "data"),
                "-mycnf_innodb_log_group_home_dir",
                os.path.join(self.tablet_dir, "innodb", "logs"),
                "-mycnf_socket_file",
                os.path.join(self.tablet_dir, "mysql.sock"),
                "-mycnf_error_log_path",
                os.path.join(self.tablet_dir, "error.log"),
                "-mycnf_slow_log_path",
                os.path.join(self.tablet_dir, "slow-query.log"),
                "-mycnf_relay_log_path",
                relay_log_path,
                "-mycnf_relay_log_index_path",
                relay_log_path + ".index",
                "-mycnf_relay_log_info_path",
                os.path.join(self.tablet_dir, "relay-logs", "relay-log.info"),
                "-mycnf_bin_log_path",
                os.path.join(self.tablet_dir, "bin-logs",
                             "vt-%010d-bin" % self.tablet_uid),
                "-mycnf_master_info_file",
                os.path.join(self.tablet_dir, "master.info"),
                "-mycnf_pid_file",
                os.path.join(self.tablet_dir, "mysql.pid"),
                "-mycnf_tmp_dir",
                os.path.join(self.tablet_dir, "tmp"),
                "-mycnf_slave_load_tmp_dir",
                os.path.join(self.tablet_dir, "tmp"),
            ])

        if memcache:
            args.extend(["-rowcache-bin", environment.memcached_bin()])
            memcache_socket = os.path.join(self.tablet_dir, "memcache.sock")
            args.extend(["-rowcache-socket", memcache_socket])
            args.extend(["-enable-rowcache"])

        if auth:
            args.extend([
                '-auth-credentials',
                os.path.join(environment.vttop, 'test', 'test_data',
                             'authcredentials_test.json')
            ])

        if customrules:
            args.extend(['-customrules', customrules])

        if schema_override:
            args.extend(['-schema-override', schema_override])

        if cert:
            self.secure_port = environment.reserve_ports(1)
            args.extend([
                '-secure-port',
                '%s' % self.secure_port, '-cert', cert, '-key', key
            ])
            if ca_cert:
                args.extend(['-ca_cert', ca_cert])
        if sensitive_mode:
            args.extend(['-queryserver-config-sensitive-mode'])
        if target_tablet_type:
            args.extend([
                '-target_tablet_type', target_tablet_type,
                '-health_check_interval', '2s', '-allowed_replication_lag',
                '30'
            ])
        if lameduck_period:
            args.extend(['-lameduck-period', lameduck_period])
        if extra_args:
            args.extend(extra_args)
        if security_policy:
            args.extend(['-security_policy', security_policy])

        stderr_fd = open(os.path.join(self.tablet_dir, "vttablet.stderr"), "w")
        # increment count only the first time
        if not self.proc:
            Tablet.tablets_running += 1
        self.proc = utils.run_bg(args, stderr=stderr_fd)
        stderr_fd.close()

        # wait for zookeeper PID just to be sure we have it
        if environment.topo_server_implementation == 'zookeeper':
            utils.run(environment.binary_path('zk') + ' wait -e ' +
                      self.zk_pid,
                      stdout=utils.devnull)

        # wait for query service to be in the right state
        if wait_for_state:
            self.wait_for_vttablet_state(wait_for_state, port=port)

        return self.proc
Beispiel #24
0
  def start_vttablet(self, port=None, auth=False, memcache=False,
                     wait_for_state='SERVING', customrules=None,
                     schema_override=None, cert=None, key=None, ca_cert=None,
                     repl_extra_flags={}, table_acl_config=None,
                     target_tablet_type=None, lameduck_period=None,
                     extra_args=None, full_mycnf_args=False,
                     security_policy=None):
    """Starts a vttablet process, and returns it.

    The process is also saved in self.proc, so it's easy to kill as well.
    """
    environment.prog_compile('vtaction')
    args = environment.binary_args('vttablet') + [
        '-port', '%s' % (port or self.port),
        '-tablet-path', self.tablet_alias,
        '-log_dir', environment.vtlogroot]
    args.extend(environment.topo_server_flags())
    args.extend(utils.binlog_player_protocol_flags)

    dbconfigs = self._get_db_configs_file(repl_extra_flags)
    for key1 in dbconfigs:
      for key2 in dbconfigs[key1]:
        args.extend(['-db-config-' + key1 + '-' + key2, dbconfigs[key1][key2]])

    if full_mycnf_args:
      # this flag is used to specify all the mycnf_ flags, to make
      # sure that code works and can fork actions.
      relay_log_path = os.path.join(self.tablet_dir, 'relay-logs',
                                    'vt-%010d-relay-bin' % self.tablet_uid)
      args.extend([
          '-mycnf_server_id', str(self.tablet_uid),
          '-mycnf_mysql_port', str(self.mysql_port),
          '-mycnf_data_dir', os.path.join(self.tablet_dir, 'data'),
          '-mycnf_innodb_data_home_dir', os.path.join(self.tablet_dir,
                                                      'innodb', 'data'),
          '-mycnf_innodb_log_group_home_dir', os.path.join(self.tablet_dir,
                                                           'innodb', 'logs'),
          '-mycnf_socket_file', os.path.join(self.tablet_dir, 'mysql.sock'),
          '-mycnf_error_log_path', os.path.join(self.tablet_dir, 'error.log'),
          '-mycnf_slow_log_path', os.path.join(self.tablet_dir,
                                               'slow-query.log'),
          '-mycnf_relay_log_path', relay_log_path,
          '-mycnf_relay_log_index_path', relay_log_path + '.index',
          '-mycnf_relay_log_info_path', os.path.join(self.tablet_dir,
                                                     'relay-logs',
                                                     'relay-log.info'),
          '-mycnf_bin_log_path', os.path.join(self.tablet_dir, 'bin-logs',
                                              'vt-%010d-bin' % self.tablet_uid),
          '-mycnf_master_info_file', os.path.join(self.tablet_dir,
                                                  'master.info'),
          '-mycnf_pid_file', os.path.join(self.tablet_dir, 'mysql.pid'),
          '-mycnf_tmp_dir', os.path.join(self.tablet_dir, 'tmp'),
          '-mycnf_slave_load_tmp_dir', os.path.join(self.tablet_dir, 'tmp'),
      ])

    if memcache:
      args.extend(['-rowcache-bin', environment.memcached_bin()])
      memcache_socket = os.path.join(self.tablet_dir, 'memcache.sock')
      args.extend(['-rowcache-socket', memcache_socket])
      args.extend(['-enable-rowcache'])

    if auth:
      args.extend(
          ['-auth-credentials',
           os.path.join(
               environment.vttop, 'test', 'test_data',
               'authcredentials_test.json')])

    if customrules:
      args.extend(['-customrules', customrules])

    if schema_override:
      args.extend(['-schema-override', schema_override])

    if table_acl_config:
      args.extend(['-table-acl-config', table_acl_config])
      args.extend(['-queryserver-config-strict-table-acl'])

    if cert:
      self.secure_port = environment.reserve_ports(1)
      args.extend(['-secure-port', '%s' % self.secure_port,
                   '-cert', cert,
                   '-key', key])
      if ca_cert:
        args.extend(['-ca_cert', ca_cert])
    if target_tablet_type:
      args.extend(['-target_tablet_type', target_tablet_type,
                   '-health_check_interval', '2s',
                   '-allowed_replication_lag', '30'])
    if lameduck_period:
      args.extend(['-lameduck-period', lameduck_period])
    if extra_args:
      args.extend(extra_args)
    if security_policy:
      args.extend(['-security_policy', security_policy])

    stderr_fd = open(os.path.join(self.tablet_dir, 'vttablet.stderr'), 'w')
    # increment count only the first time
    if not self.proc:
      Tablet.tablets_running += 1
    self.proc = utils.run_bg(args, stderr=stderr_fd)
    stderr_fd.close()

    # wait for query service to be in the right state
    if wait_for_state:
      self.wait_for_vttablet_state(wait_for_state, port=port)

    return self.proc
Beispiel #25
0
    def start_vttablet(self,
                       port=None,
                       auth=False,
                       memcache=False,
                       wait_for_state='SERVING',
                       customrules=None,
                       schema_override=None,
                       cert=None,
                       key=None,
                       ca_cert=None,
                       repl_extra_flags={},
                       table_acl_config=None,
                       lameduck_period=None,
                       security_policy=None,
                       target_tablet_type=None,
                       full_mycnf_args=False,
                       extra_args=None,
                       extra_env=None,
                       include_mysql_port=True):
        """Starts a vttablet process, and returns it.

    The process is also saved in self.proc, so it's easy to kill as well.
    """
        args = []
        args.extend(['-tablet-path', self.tablet_alias])
        args.extend(environment.topo_server_flags())
        args.extend(utils.binlog_player_protocol_flags)
        args.extend(environment.tablet_manager_protocol_flags())
        args.extend(
            ['-pid_file',
             os.path.join(self.tablet_dir, 'vttablet.pid')])

        if full_mycnf_args:
            # this flag is used to specify all the mycnf_ flags, to make
            # sure that code works and can fork actions.
            relay_log_path = os.path.join(
                self.tablet_dir, 'relay-logs',
                'vt-%010d-relay-bin' % self.tablet_uid)
            args.extend([
                '-mycnf_server_id',
                str(self.tablet_uid),
                '-mycnf_data_dir',
                os.path.join(self.tablet_dir, 'data'),
                '-mycnf_innodb_data_home_dir',
                os.path.join(self.tablet_dir, 'innodb', 'data'),
                '-mycnf_innodb_log_group_home_dir',
                os.path.join(self.tablet_dir, 'innodb', 'logs'),
                '-mycnf_socket_file',
                os.path.join(self.tablet_dir, 'mysql.sock'),
                '-mycnf_error_log_path',
                os.path.join(self.tablet_dir, 'error.log'),
                '-mycnf_slow_log_path',
                os.path.join(self.tablet_dir, 'slow-query.log'),
                '-mycnf_relay_log_path',
                relay_log_path,
                '-mycnf_relay_log_index_path',
                relay_log_path + '.index',
                '-mycnf_relay_log_info_path',
                os.path.join(self.tablet_dir, 'relay-logs', 'relay-log.info'),
                '-mycnf_bin_log_path',
                os.path.join(self.tablet_dir, 'bin-logs',
                             'vt-%010d-bin' % self.tablet_uid),
                '-mycnf_master_info_file',
                os.path.join(self.tablet_dir, 'master.info'),
                '-mycnf_pid_file',
                os.path.join(self.tablet_dir, 'mysql.pid'),
                '-mycnf_tmp_dir',
                os.path.join(self.tablet_dir, 'tmp'),
                '-mycnf_slave_load_tmp_dir',
                os.path.join(self.tablet_dir, 'tmp'),
            ])
            if include_mysql_port:
                args.extend(['-mycnf_mysql_port', str(self.mysql_port)])
        if target_tablet_type:
            args.extend([
                '-target_tablet_type', target_tablet_type,
                '-health_check_interval', '2s', '-allowed_replication_lag',
                '30'
            ])

        if extra_args:
            args.extend(extra_args)

        return self._start_prog(binary='vttablet',
                                port=port,
                                auth=auth,
                                memcache=memcache,
                                wait_for_state=wait_for_state,
                                customrules=customrules,
                                schema_override=schema_override,
                                cert=cert,
                                key=key,
                                ca_cert=ca_cert,
                                repl_extra_flags=repl_extra_flags,
                                table_acl_config=table_acl_config,
                                lameduck_period=lameduck_period,
                                extra_args=args,
                                security_policy=security_policy,
                                extra_env=extra_env)
Beispiel #26
0
    def test_reparent_down_master(self):
        utils.run_vtctl('CreateKeyspace test_keyspace')

        # create the database so vttablets start, as they are serving
        tablet_62344.create_db('vt_test_keyspace')
        tablet_62044.create_db('vt_test_keyspace')
        tablet_41983.create_db('vt_test_keyspace')
        tablet_31981.create_db('vt_test_keyspace')

        # Start up a master mysql and vttablet
        tablet_62344.init_tablet('master',
                                 'test_keyspace',
                                 '0',
                                 start=True,
                                 wait_for_start=False)

        # Create a few slaves for testing reparenting.
        tablet_62044.init_tablet('replica',
                                 'test_keyspace',
                                 '0',
                                 start=True,
                                 wait_for_start=False)
        tablet_41983.init_tablet('replica',
                                 'test_keyspace',
                                 '0',
                                 start=True,
                                 wait_for_start=False)
        tablet_31981.init_tablet('replica',
                                 'test_keyspace',
                                 '0',
                                 start=True,
                                 wait_for_start=False)

        # wait for all tablets to start
        for t in [tablet_62344, tablet_62044, tablet_41983, tablet_31981]:
            t.wait_for_vttablet_state("SERVING")

        # Recompute the shard layout node - until you do that, it might not be valid.
        utils.run_vtctl('RebuildShardGraph test_keyspace/0')
        utils.validate_topology()

        # Force the slaves to reparent assuming that all the datasets are identical.
        for t in [tablet_62344, tablet_62044, tablet_41983, tablet_31981]:
            t.reset_replication()
        utils.run_vtctl('ReparentShard -force test_keyspace/0 ' +
                        tablet_62344.tablet_alias,
                        auto_log=True)
        utils.validate_topology()

        # Make the master agent and database unavailable.
        tablet_62344.kill_vttablet()
        tablet_62344.shutdown_mysql().wait()

        self._check_db_addr('0', 'master', tablet_62344.port)

        # Perform a reparent operation - the Validate part will try to ping
        # the master and fail somewhat quickly
        stdout, stderr = utils.run_vtctl(
            '-wait-time 5s ReparentShard test_keyspace/0 ' +
            tablet_62044.tablet_alias,
            expect_fail=True)
        logging.debug("Failed ReparentShard output:\n" + stderr)
        if 'ValidateShard verification failed' not in stderr:
            self.fail(
                "didn't find the right error strings in failed ReparentShard: "
                + stderr)

        # Should timeout and fail
        stdout, stderr = utils.run_vtctl('-wait-time 5s ScrapTablet ' +
                                         tablet_62344.tablet_alias,
                                         expect_fail=True)
        logging.debug("Failed ScrapTablet output:\n" + stderr)
        if 'deadline exceeded' not in stderr:
            self.fail(
                "didn't find the right error strings in failed ScrapTablet: " +
                stderr)

        # Should interrupt and fail
        args = [
            environment.binary_path('vtctl'), '-log_dir',
            environment.vtlogroot, '-wait-time', '10s'
        ]
        args.extend(environment.topo_server_flags())
        args.extend(environment.tablet_manager_protocol_flags())
        args.extend(['ScrapTablet', tablet_62344.tablet_alias])
        sp = utils.run_bg(args, stdout=PIPE, stderr=PIPE)
        # Need time for the process to start before killing it.
        time.sleep(3.0)
        os.kill(sp.pid, signal.SIGINT)
        stdout, stderr = sp.communicate()

        logging.debug("Failed ScrapTablet output:\n" + stderr)
        if 'interrupted' not in stderr:
            self.fail(
                "didn't find the right error strings in failed ScrapTablet: " +
                stderr)

        # Force the scrap action in zk even though tablet is not accessible.
        tablet_62344.scrap(force=True)

        utils.run_vtctl('ChangeSlaveType -force %s idle' %
                        tablet_62344.tablet_alias,
                        expect_fail=True)

        # Remove pending locks (make this the force option to ReparentShard?)
        if environment.topo_server_implementation == 'zookeeper':
            utils.run_vtctl(
                'PurgeActions /zk/global/vt/keyspaces/test_keyspace/shards/0/action'
            )

        # Re-run reparent operation, this shoud now proceed unimpeded.
        utils.run_vtctl('-wait-time 1m ReparentShard test_keyspace/0 ' +
                        tablet_62044.tablet_alias,
                        auto_log=True)

        utils.validate_topology()
        self._check_db_addr('0', 'master', tablet_62044.port)

        utils.run_vtctl(
            ['ChangeSlaveType', '-force', tablet_62344.tablet_alias, 'idle'])

        idle_tablets, _ = utils.run_vtctl('ListAllTablets test_nj',
                                          trap_output=True)
        if '0000062344 <null> <null> idle' not in idle_tablets:
            self.fail('idle tablet not found: %s' % idle_tablets)

        tablet.kill_tablets([tablet_62044, tablet_41983, tablet_31981])

        # so the other tests don't have any surprise
        tablet_62344.start_mysql().wait()