def connect_mc(host, port, username, password, bucket):
username = str(username).encode("ascii")
password = str(password).encode("ascii")
if bucket is not None:
bucket = str(bucket).encode("ascii")
return pump.get_mcd_conn(host, port, username, password, bucket)
def connect_mc(host: str, port: int, username: str, password: str, bucket: Optional[str], use_ssl: bool = False,
verify: bool = True, ca_cert: str = None, collections: bool = False)-> \
Tuple[couchbaseConstants.PUMP_ERROR, Optional[cb_bin_client.MemcachedClient]]:
return pump.get_mcd_conn(host,
port,
username,
password,
bucket,
use_ssl=use_ssl,
verify=verify,
ca_cert=ca_cert,
collections=collections)
def get_dcp_conn(self):
"""Return previously connected dcp conn."""
if not self.dcp_conn:
host, _ = pump.hostport(self.source_node['hostname'])
port = self.source_node['ports']['direct']
username = self.opts.username
password = self.opts.password
bucket = str(self.source_bucket.get("name"))
if self.opts.ssl:
port = couchbaseConstants.SSL_PORT
if getattr(self, 'alt_add', None):
if 'alternateAddresses' in self.source_node:
host = self.source_node['alternateAddresses']['external'][
'hostname']
if 'ports' not in self.source_node['alternateAddresses'][
'external']:
return [
'no data port available in external address: {}'.
format(host)
], None
alterante_ports = self.source_node['alternateAddresses'][
'external']['ports']
if self.opts.ssl:
if 'kvSSL' not in alterante_ports:
return [
'Secure data port not available in external host: {}'
.format(host)
]
port = alterante_ports['kvSSL']
elif 'kv' not in alterante_ports:
return [
'Data port not available in external host: {}'.
format(host)
]
else:
port = alterante_ports['kv']
else:
return [
'alterante address not available in node: {}'.format(
self.source_node['otpNode'])
], None
logging.debug(f' DCPStreamSource connecting mc: {host}:{port!s}')
err, self.dcp_conn = pump.get_mcd_conn(host, port, username,
password, bucket,
self.opts.ssl,
self.opts.no_ssl_verify,
self.opts.cacert)
if err:
return err, None
err, self.mem_conn = pump.get_mcd_conn(host, port, username,
password, bucket,
self.opts.ssl,
self.opts.no_ssl_verify,
self.opts.cacert)
if err:
return err, None
flags = couchbaseConstants.FLAG_DCP_PRODUCER | couchbaseConstants.FLAG_DCP_XATTRS
extra = struct.pack(couchbaseConstants.DCP_CONNECT_PKT_FMT, 0,
flags)
try:
opaque = self.r.randint(0, 2**32)
self.dcp_conn._send_cmd(couchbaseConstants.CMD_DCP_CONNECT,
self.dcp_name.encode(), b'', opaque,
extra)
self.dcp_conn._handle_single_response(opaque)
opaque = self.r.randint(0, 2**32)
self.dcp_conn._send_cmd(
couchbaseConstants.CMD_DCP_CONTROL,
couchbaseConstants.KEY_DCP_CONNECTION_BUFFER_SIZE,
str(self.batch_max_bytes * 10).encode(), opaque)
self.dcp_conn._handle_single_response(opaque)
opaque = self.r.randint(0, 2**32)
self.dcp_conn._send_cmd(couchbaseConstants.CMD_DCP_CONTROL,
couchbaseConstants.KEY_DCP_NOOP,
b'true', opaque)
self.dcp_conn._handle_single_response(opaque)
opaque = self.r.randint(0, 2**32)
self.dcp_conn._send_cmd(
couchbaseConstants.CMD_DCP_CONTROL,
couchbaseConstants.KEY_DCP_NOOP_INTERVAL, b'180', opaque)
self.dcp_conn._handle_single_response(opaque)
except EOFError:
return "error: Fail to set up DCP connection"
except cb_bin_client.MemcachedError:
return "error: DCP connect memcached error"
except socket.error:
return "error: DCP connection error"
try:
opaque = self.r.randint(0, 2**32)
self.dcp_conn._send_cmd(
couchbaseConstants.CMD_DCP_CONTROL,
couchbaseConstants.KEY_DCP_EXT_METADATA,
bool_to_str(True).encode(), opaque)
self.dcp_conn._handle_single_response(opaque)
except EOFError:
return "error: Fail to set up DCP connection"
except cb_bin_client.MemcachedError:
pass
except socket.error:
return "error: DCP connection error"
self.running = True
self.start()
self.add_start_event(self.dcp_conn)
self.setup_dcp_streams()
return 0
def get_dcp_conn(self):
"""Return previously connected dcp conn."""
if not self.dcp_conn:
host, _ = pump.hostport(self.source_node['hostname'])
port = self.source_node['ports']['direct']
username = self.opts.username
password = self.opts.password
bucket = str(self.source_bucket.get("name"))
if self.opts.ssl:
port = couchbaseConstants.SSL_PORT
logging.debug(" DCPStreamSource connecting mc: " + host + ":" +
str(port))
err, self.dcp_conn = pump.get_mcd_conn(host, port, username,
password, bucket,
self.opts.ssl,
self.opts.no_ssl_verify,
self.opts.cacert)
if err:
return err, None
err, self.mem_conn = pump.get_mcd_conn(host, port, username,
password, bucket,
self.opts.ssl,
self.opts.no_ssl_verify,
self.opts.cacert)
if err:
return err, None
flags = couchbaseConstants.FLAG_DCP_PRODUCER | couchbaseConstants.FLAG_DCP_XATTRS
extra = struct.pack(couchbaseConstants.DCP_CONNECT_PKT_FMT, 0,
flags)
try:
opaque = self.r.randint(0, 2**32)
self.dcp_conn._sendCmd(couchbaseConstants.CMD_DCP_CONNECT, self.dcp_name, \
'', opaque, extra)
self.dcp_conn._handleSingleResponse(opaque)
buff_size = 0
if self.flow_control:
# set connection buffer size. Considering header size, we roughly
# set the total received package size as 10 times as value size.
buff_size = self.batch_max_bytes * 10
opaque = self.r.randint(0, 2**32)
self.dcp_conn._sendCmd(
couchbaseConstants.CMD_DCP_CONTROL,
couchbaseConstants.KEY_DCP_CONNECTION_BUFFER_SIZE,
str(self.batch_max_bytes * 10), opaque)
self.dcp_conn._handleSingleResponse(opaque)
opaque = self.r.randint(0, 2**32)
self.dcp_conn._sendCmd(couchbaseConstants.CMD_DCP_CONTROL,
couchbaseConstants.KEY_DCP_NOOP, "true",
opaque)
self.dcp_conn._handleSingleResponse(opaque)
opaque = self.r.randint(0, 2**32)
self.dcp_conn._sendCmd(
couchbaseConstants.CMD_DCP_CONTROL,
couchbaseConstants.KEY_DCP_NOOP_INTERVAL, str(180), opaque)
self.dcp_conn._handleSingleResponse(opaque)
except EOFError:
return "error: Fail to set up DCP connection"
except cb_bin_client.MemcachedError:
return "error: DCP connect memcached error"
except socket.error:
return "error: DCP connection error"
try:
opaque = self.r.randint(0, 2**32)
self.dcp_conn._sendCmd(couchbaseConstants.CMD_DCP_CONTROL,
couchbaseConstants.KEY_DCP_EXT_METADATA,
bool_to_str(True), opaque)
self.dcp_conn._handleSingleResponse(opaque)
except EOFError:
return "error: Fail to set up DCP connection"
except cb_bin_client.MemcachedError:
pass
except socket.error:
return "error: DCP connection error"
self.running = True
self.start()
self.add_start_event(self.dcp_conn)
self.setup_dcp_streams()
return 0
def connect_mc(host: str, port: int, username: str, password: str, bucket: Optional[str], use_ssl: bool = False,
verify: bool = True, ca_cert: str = None, collections: bool = False)-> \
Tuple[couchbaseConstants.PUMP_ERROR, Optional[cb_bin_client.MemcachedClient]]:
return pump.get_mcd_conn(host, port, username, password, bucket, use_ssl=use_ssl, verify=verify,
ca_cert=ca_cert, collections=collections)
def get_dcp_conn(self):
"""Return previously connected dcp conn."""
if not self.dcp_conn:
host, _ = pump.hostport(self.source_node['hostname'])
port = self.source_node['ports']['direct']
username = self.opts.username
password = self.opts.password
bucket = str(self.source_bucket.get("name"))
if self.opts.ssl:
port = couchbaseConstants.SSL_PORT
if getattr(self, 'alt_add', None):
if 'alternateAddresses' in self.source_node:
host = self.source_node['alternateAddresses']['external']['hostname']
if 'ports' not in self.source_node['alternateAddresses']['external']:
return ['no data port available in external address: {}'. format(host)], None
alterante_ports = self.source_node['alternateAddresses']['external']['ports']
if self.opts.ssl:
if 'kvSSL' not in alterante_ports:
return ['Secure data port not available in external host: {}'.format(host)]
port = alterante_ports['kvSSL']
elif 'kv' not in alterante_ports:
return ['Data port not available in external host: {}'.format(host)]
else:
port = alterante_ports['kv']
else:
return ['alterante address not available in node: {}'.format(self.source_node['otpNode'])], None
logging.debug(f' DCPStreamSource connecting mc: {host}:{port!s}')
err, self.dcp_conn = pump.get_mcd_conn(host, port, username, password, bucket, self.opts.ssl,
self.opts.no_ssl_verify, self.opts.cacert)
if err:
return err, None
err, self.mem_conn = pump.get_mcd_conn(host, port, username, password, bucket, self.opts.ssl,
self.opts.no_ssl_verify, self.opts.cacert)
if err:
return err, None
flags = couchbaseConstants.FLAG_DCP_PRODUCER | couchbaseConstants.FLAG_DCP_XATTRS
extra = struct.pack(couchbaseConstants.DCP_CONNECT_PKT_FMT, 0, flags)
try:
opaque = self.r.randint(0, 2**32)
self.dcp_conn._sendCmd(couchbaseConstants.CMD_DCP_CONNECT, self.dcp_name.encode() , b'', opaque, extra)
self.dcp_conn._handleSingleResponse(opaque)
buff_size = 0
if self.flow_control:
# set connection buffer size. Considering header size, we roughly
# set the total received package size as 10 times as value size.
buff_size = self.batch_max_bytes * 10
opaque=self.r.randint(0, 2**32)
self.dcp_conn._sendCmd(couchbaseConstants.CMD_DCP_CONTROL,
couchbaseConstants.KEY_DCP_CONNECTION_BUFFER_SIZE,
str(self.batch_max_bytes * 10).encode(), opaque)
self.dcp_conn._handleSingleResponse(opaque)
opaque=self.r.randint(0, 2**32)
self.dcp_conn._sendCmd(couchbaseConstants.CMD_DCP_CONTROL,
couchbaseConstants.KEY_DCP_NOOP, b'true', opaque)
self.dcp_conn._handleSingleResponse(opaque)
opaque=self.r.randint(0, 2**32)
self.dcp_conn._sendCmd(couchbaseConstants.CMD_DCP_CONTROL,
couchbaseConstants.KEY_DCP_NOOP_INTERVAL,
b'180', opaque)
self.dcp_conn._handleSingleResponse(opaque)
except EOFError:
return "error: Fail to set up DCP connection"
except cb_bin_client.MemcachedError:
return "error: DCP connect memcached error"
except socket.error:
return "error: DCP connection error"
try:
opaque=self.r.randint(0, 2**32)
self.dcp_conn._sendCmd(couchbaseConstants.CMD_DCP_CONTROL,
couchbaseConstants.KEY_DCP_EXT_METADATA,
bool_to_str(True).encode(), opaque)
self.dcp_conn._handleSingleResponse(opaque)
except EOFError:
return "error: Fail to set up DCP connection"
except cb_bin_client.MemcachedError:
pass
except socket.error:
return "error: DCP connection error"
self.running = True
self.start()
self.add_start_event(self.dcp_conn)
self.setup_dcp_streams()
return 0
def get_dcp_conn(self):
"""Return previously connected dcp conn."""
if not self.dcp_conn:
host, _ = pump.hostport(self.source_node['hostname'])
port = self.source_node['ports']['direct']
username = self.opts.username
password = self.opts.password
bucket = str(self.source_bucket.get("name"))
if self.opts.ssl:
port = couchbaseConstants.SSL_PORT
logging.debug(" DCPStreamSource connecting mc: " + host + ":" + str(port))
err, self.dcp_conn = pump.get_mcd_conn(host, port, username, password, bucket)
if err:
return err, None
err, self.mem_conn = pump.get_mcd_conn(host, port, username, password, bucket)
if err:
return err, None
flags = couchbaseConstants.FLAG_DCP_PRODUCER | couchbaseConstants.FLAG_DCP_XATTRS
extra = struct.pack(couchbaseConstants.DCP_CONNECT_PKT_FMT, 0, flags)
try:
opaque=self.r.randint(0, 2**32)
self.dcp_conn._sendCmd(couchbaseConstants.CMD_DCP_CONNECT, self.dcp_name, \
'', opaque, extra)
self.dcp_conn._handleSingleResponse(opaque)
buff_size = 0
if self.flow_control:
# set connection buffer size. Considering header size, we roughly
# set the total received package size as 10 times as value size.
buff_size = self.batch_max_bytes * 10
opaque=self.r.randint(0, 2**32)
self.dcp_conn._sendCmd(couchbaseConstants.CMD_DCP_CONTROL,
couchbaseConstants.KEY_DCP_CONNECTION_BUFFER_SIZE,
str(self.batch_max_bytes * 10), opaque)
self.dcp_conn._handleSingleResponse(opaque)
opaque=self.r.randint(0, 2**32)
self.dcp_conn._sendCmd(couchbaseConstants.CMD_DCP_CONTROL,
couchbaseConstants.KEY_DCP_NOOP,
"true", opaque)
self.dcp_conn._handleSingleResponse(opaque)
opaque=self.r.randint(0, 2**32)
self.dcp_conn._sendCmd(couchbaseConstants.CMD_DCP_CONTROL,
couchbaseConstants.KEY_DCP_NOOP_INTERVAL,
str(180), opaque)
self.dcp_conn._handleSingleResponse(opaque)
except EOFError:
return "error: Fail to set up DCP connection"
except cb_bin_client.MemcachedError:
return "error: DCP connect memcached error"
except socket.error:
return "error: DCP connection error"
try:
opaque=self.r.randint(0, 2**32)
self.dcp_conn._sendCmd(couchbaseConstants.CMD_DCP_CONTROL,
couchbaseConstants.KEY_DCP_EXT_METADATA,
bool_to_str(True), opaque)
self.dcp_conn._handleSingleResponse(opaque)
except EOFError:
return "error: Fail to set up DCP connection"
except cb_bin_client.MemcachedError:
pass
except socket.error:
return "error: DCP connection error"
self.running = True
self.start()
self.add_start_event(self.dcp_conn)
self.setup_dcp_streams()
return 0
