io.debezium.connector.sqlserver.SqlServerConnector Maven / Gradle / Ivy
/*
* Copyright Debezium Authors.
*
* Licensed under the Apache Software License version 2.0, available at http://www.apache.org/licenses/LICENSE-2.0
*/
package io.debezium.connector.sqlserver;
import static io.debezium.config.CommonConnectorConfig.TASK_ID;
import static io.debezium.connector.sqlserver.SqlServerConnectorConfig.DATABASE_NAMES;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
import org.apache.kafka.common.config.ConfigDef;
import org.apache.kafka.common.config.ConfigValue;
import org.apache.kafka.connect.connector.Task;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import io.debezium.DebeziumException;
import io.debezium.config.Configuration;
import io.debezium.connector.common.RelationalBaseSourceConnector;
import io.debezium.relational.RelationalDatabaseConnectorConfig;
import io.debezium.relational.TableId;
/**
* The main connector class used to instantiate configuration and execution classes
*
* @author Jiri Pechanec
*
*/
public class SqlServerConnector extends RelationalBaseSourceConnector {
private static final Logger LOGGER = LoggerFactory.getLogger(SqlServerConnector.class);
private Map properties;
@Override
public String version() {
return Module.version();
}
@Override
public void start(Map props) {
this.properties = Collections.unmodifiableMap(new HashMap<>(props));
}
@Override
public Class taskClass() {
return SqlServerConnectorTask.class;
}
@Override
public List> taskConfigs(int maxTasks) {
if (maxTasks > 1 && !properties.containsKey(DATABASE_NAMES.name())) {
throw new IllegalArgumentException("Only a single connector task may be started in single-partition mode");
}
final SqlServerConnectorConfig config = new SqlServerConnectorConfig(Configuration.from(properties));
try (SqlServerConnection connection = connect(config)) {
return buildTaskConfigs(connection, config, maxTasks);
}
catch (SQLException e) {
throw new IllegalArgumentException("Could not build task configs", e);
}
}
private List> buildTaskConfigs(SqlServerConnection connection, SqlServerConnectorConfig config,
int maxTasks) {
List databaseNames = config.getDatabaseNames();
// Initialize the database list for each task
List> databasesByTask = new ArrayList<>();
final int numTasks = Math.min(maxTasks, config.getDatabaseNames().size());
for (int i = 0; i < numTasks; i++) {
databasesByTask.add(new ArrayList<>());
}
// Add each database to a task list via round-robin.
for (int databaseNameIndex = 0; databaseNameIndex < databaseNames.size(); databaseNameIndex++) {
int taskIndex = databaseNameIndex % numTasks;
String realDatabaseName = connection.retrieveRealDatabaseName(databaseNames.get(databaseNameIndex));
databasesByTask.get(taskIndex).add(realDatabaseName);
}
// Create a task config for each task, assigning each a list of database names.
List> taskConfigs = new ArrayList<>();
for (int taskIndex = 0; taskIndex < numTasks; taskIndex++) {
String taskDatabases = String.join(",", databasesByTask.get(taskIndex));
Map taskProperties = new HashMap<>(properties);
taskProperties.put(SqlServerConnectorConfig.DATABASE_NAMES.name(), taskDatabases);
taskProperties.put(TASK_ID, String.valueOf(taskIndex));
taskConfigs.add(Collections.unmodifiableMap(taskProperties));
}
return taskConfigs;
}
@Override
public void stop() {
}
@Override
public ConfigDef config() {
return SqlServerConnectorConfig.configDef();
}
@Override
protected void validateConnection(Map configValues, Configuration config) {
if (!configValues.get(DATABASE_NAMES.name()).errorMessages().isEmpty()) {
return;
}
final SqlServerConnectorConfig sqlServerConfig = new SqlServerConnectorConfig(config);
final ConfigValue hostnameValue = configValues.get(RelationalDatabaseConnectorConfig.HOSTNAME.name());
final ConfigValue userValue = configValues.get(RelationalDatabaseConnectorConfig.USER.name());
// Try to connect to the database ...
try (SqlServerConnection connection = connect(sqlServerConfig)) {
connection.execute("SELECT @@VERSION");
LOGGER.debug("Successfully tested connection for {} with user '{}'", connection.connectionString(),
connection.username());
LOGGER.info("Checking if user has access to CDC table");
if (sqlServerConfig.getSnapshotMode() != SqlServerConnectorConfig.SnapshotMode.INITIAL_ONLY) {
final List noAccessDatabaseNames = new ArrayList<>();
for (String databaseName : sqlServerConfig.getDatabaseNames()) {
if (!connection.checkIfConnectedUserHasAccessToCDCTable(databaseName)) {
noAccessDatabaseNames.add(databaseName);
}
}
if (!noAccessDatabaseNames.isEmpty()) {
String errorMessage = String.format(
"User %s does not have access to CDC schema in the following databases: %s. This user can only be used in initial_only snapshot mode",
config.getString(RelationalDatabaseConnectorConfig.USER), String.join(", ", noAccessDatabaseNames));
LOGGER.error(errorMessage);
userValue.addErrorMessage(errorMessage);
}
}
}
catch (Exception e) {
LOGGER.error("Failed testing connection for {} with user '{}'", config.withMaskedPasswords(),
userValue, e);
hostnameValue.addErrorMessage("Unable to connect. Check this and other connection properties. Error: "
+ e.getMessage());
}
}
@Override
protected Map validateAllFields(Configuration config) {
return config.validate(SqlServerConnectorConfig.ALL_FIELDS);
}
private SqlServerConnection connect(SqlServerConnectorConfig sqlServerConfig) {
return new SqlServerConnection(sqlServerConfig, null, Collections.emptySet(),
sqlServerConfig.useSingleDatabase());
}
@SuppressWarnings("unchecked")
@Override
public List getMatchingCollections(Configuration config) {
final SqlServerConnectorConfig connectorConfig = new SqlServerConnectorConfig(config);
final List databaseNames = connectorConfig.getDatabaseNames();
try (SqlServerConnection connection = connect(connectorConfig)) {
List tables = new ArrayList<>();
databaseNames.forEach(databaseName -> {
try {
tables.addAll(
connection.readTableNames(databaseName, null, null, new String[]{ "TABLE" }).stream()
.filter(tableId -> connectorConfig.getTableFilters().dataCollectionFilter().isIncluded(tableId))
.collect(Collectors.toList()));
}
catch (SQLException e) {
throw new DebeziumException(e);
}
});
return tables;
}
catch (SQLException e) {
throw new RuntimeException("Could not retrieve real database name", e);
}
}
}