tungsten抽取和应用mysql binlog

• 首先举例说明 api的基本使用方式

首先进行配置 ， 可以看到源数据库和目的数据库

TungstenProperties tp=new TungstenProperties();
  tp.setString(ReplicatorConf.SERVICE_NAME,"test");
  tp.setString(ReplicatorConf.ROLE,ReplicatorConf.ROLE_MASTER);
  tp.setString(ReplicatorConf.PIPELINES,"master");
  tp.setString(ReplicatorConf.PIPELINE_ROOT + ".master","extract");
  tp.setString(ReplicatorConf.STAGE_ROOT + ".extract",SingleThreadStageTask.class.toString());
  tp.setString(ReplicatorConf.STAGE_ROOT + ".extract.extractor","mysql");
  tp.setString(ReplicatorConf.STAGE_ROOT + ".extract.applier","mysql");

  String mysqlExtractor=ReplicatorConf.EXTRACTOR_ROOT + ".mysql";
  tp.setString(ReplicatorConf.EXTRACTOR_ROOT,"mysql");
  tp.setString(mysqlExtractor,MySQLExtractor.class.getName());
  tp.setString(mysqlExtractor + ".binlog_dir","/var/lib/mysql");
  tp.setString(mysqlExtractor + ".binlog_file_pattern","mysql-bin");
  tp.setString(mysqlExtractor + ".host","localhost");
  tp.setString(mysqlExtractor + ".user","tungsten");
  tp.setString(mysqlExtractor + ".password","secret");

  String mysqlApplier=ReplicatorConf.APPLIER_ROOT + ".mysql";
  tp.setString(ReplicatorConf.APPLIER_ROOT,"mysql");
  tp.setString(mysqlApplier,MySQLApplier.class.getName());
  tp.setString(mysqlApplier + ".host","localhost");
  tp.setString(mysqlApplier + ".port","3306");
  tp.setString(mysqlApplier + ".user","tungsten");
  tp.setString(mysqlApplier + ".password","secret");

进行抽取和应用的代码

    ReplicatorRuntime runtime = new ReplicatorRuntime(conf,
                    new MockOpenReplicatorContext(),
                    ReplicatorMonitor.getInstance());
            runtime.configure();

            MySQLExtractor extractor = getMySQLExtractor(runtime);
            extractor.setStrictVersionChecking(false);
            extractor.prepare(runtime);

            Applier applier = runtime.getApplier();
            applier.prepare(runtime);

            for (int i = 0; i < 7; i++) //通常这里会循环下去，不断接受event，并且apply
            {
                DBMSEvent event = extractor.extract();
                if (event != null)
                {
                    applier.apply(event, i, true);
                }
            }

• 接下来进行一些核心类和源码的分析

进去 extractor.extract() 方法，这个是核心的处理类，可以看到有很多event类型，包括：

AppendBlockLogEvent
TableMapLogEvent
UserVarLogEvent
XidLogEvent
StopLogEvent
RowsLogEvent
RotateLogEvent
BeginLoadQueryLogEvent
ExecuteLoadQueryLogEvent
QueryLogEvent

另外还可处理  begin commit rollback set （autocommit ， sql_mode）等命令 以及 ddl语句。

可以获取 serverId ， sessionId ，eventID 等信息。

private DBMSEvent extractEvent(BinlogReader position)
            throws ReplicatorException, InterruptedException
    {

            while (true)
            {
                DBMSEvent dbmsEvent = null;
                LogEvent logEvent = processFile(position);
                if (logEvent == null)
                {
                    logger.debug("Unknown binlog field, skipping");
                    continue;
                }

                if (serverId == -1)
                    serverId = logEvent.serverId;

                if (startTime == null)
                    startTime = logEvent.getWhen();

                if (logEvent instanceof RowsLogEvent)
                {
                    fragSize += ((RowsLogEvent) logEvent).getEventSize();
                }

                boolean doCommit = false;
                boolean doRollback = false;

                boolean unsafeForBlockCommit = false;

                if (logEvent.getClass() == QueryLogEvent.class)
                {
                    QueryLogEvent event = (QueryLogEvent) logEvent;
                    String queryString = event.getQuery();
                    StatementData statement = new StatementData(queryString);

                    // Extract the charset name if it can be found.
                    String charsetName = event.getCharsetName();
                    if (charsetName != null)
                        statement.addOption(ReplOptionParams.JAVA_CHARSET_NAME,
                                event.getCharsetName());
                    if (logger.isDebugEnabled())
                        logger.debug("Query extracted: " + queryString
                                + " charset=" + charsetName);

                    // Parse for SQL metadata and add to the statement.
                    String query;

                    if (!useBytesForStrings)
                        query = queryString;
                    else
                    {
                        // Translate only a few bytes, in order to eventually
                        // detect some keywords.
                        int len = Math.min(event.getQueryAsBytes().length, 200);
                        if (charsetName == null)
                            query = new String(event.getQueryAsBytes(), 0, len);
                        else
                            query = new String(event.getQueryAsBytes(), 0, len,
                                    charsetName);
                    }
                    SqlOperation sqlOperation = sqlMatcher.match(query);
                    statement.setParsingMetadata(sqlOperation);

                    // We must commit on DDLs and the like except for BEGIN or
                    // START TRANSACTION, since they start new transaction at
                    // the same time
                    doCommit = !inTransaction || sqlOperation.isAutoCommit();
                    int operation = sqlOperation.getOperation();
                    if (operation == SqlOperation.BEGIN)
                    {
                        inTransaction = true;
                        doCommit = false;
                        // This a a BEGIN statement : buffer session variables
                        // for following row events if any and skip it

                        /* Adding statement options */
                        savedOptions.add(new ReplOption("autocommit", event
                                .getAutocommitFlag()));
                        savedOptions.add(new ReplOption("sql_auto_is_null",
                                event.getAutoIsNullFlag()));
                        savedOptions.add(new ReplOption("foreign_key_checks",
                                event.getForeignKeyChecksFlag()));
                        savedOptions.add(new ReplOption("unique_checks", event
                                .getUniqueChecksFlag()));
                        savedOptions.add(new ReplOption("sql_mode", event
                                .getSqlMode()));
        。。。。。。

                        continue;
                    }

                    if (operation == SqlOperation.COMMIT)
                    {
                        // This is a COMMIT statement : dropping it for now
                        // Temporary workaround for TREP-243
                        doCommit = true;
                        inTransaction = !autocommitMode;
                    }
                    else if (operation == SqlOperation.ROLLBACK)
                    {
                        doRollback = true;
                        inTransaction = !autocommitMode;

                    }
                    else
                    {
                        // some optimization: it makes sense to check for
                        // 'CREATE DATABASE' only if we know that it is not
                        // regular DML - this is a fix for TREP-52 - attempt
                        // to use DB which hasn't been created yet.
                        boolean isCreateOrDropDB = sqlOperation.getObjectType() == SqlOperation.SCHEMA;
                        boolean prependUseDb = !(sqlOperation.isAutoCommit() && isCreateOrDropDB);

                        if (sessionId == -1)
                        {
                            // first query in transaction
                            sessionId = event.getSessionId();
                        }

                        if (prependUseDb)
                        {
                            statement.setDefaultSchema(event.getDefaultDb());
                        }

                        if (isCreateOrDropDB)
                            statement.addOption(
                                    StatementData.CREATE_OR_DROP_DB, "");

                        if (operation == SqlOperation.CREATE
                                || operation == SqlOperation.DROP
                                || operation == SqlOperation.ALTER
                                || operation == SqlOperation.UNRECOGNIZED)
                            unsafeForBlockCommit = true;

                        statement.setTimestamp(event.getWhen().getTime());
                        if (!useBytesForStrings)
                        {
                            statement.setQuery(queryString);
                            fragSize += queryString.length();
                        }
                        else
                        {
                            byte[] bytes = event.getQueryAsBytes();
                            statement.setQuery(bytes);
                            fragSize += bytes.length;
                        }

                        /* Adding statement options */
                        statement.addOption("autocommit",
                                event.getAutocommitFlag());
                        statement.addOption("sql_auto_is_null",
                                event.getAutoIsNullFlag());
                        statement.addOption("foreign_key_checks",
                                event.getForeignKeyChecksFlag());
                        statement.addOption("unique_checks",
                                event.getUniqueChecksFlag());
。。。。。。
                    }
                }
。。。。。。
                else if (logEvent.getClass() == XidLogEvent.class)
                {
                    logger.debug("Commit extracted: "
                            + ((XidLogEvent) logEvent).getXid());
                    // If there's nothing to commit, just ignore.
                    // Should happen for InnoDB tables in AUTOCOMMIT mode.
                    if (!dataArray.isEmpty())
                    {
                        doCommit = true;
                    }
                    if (rowChangeData != null)
                    {
                        doCommit = true;
                    }
                    // It seems like there's always explicit COMMIT event if
                    // transaction is implicitely committed,
                    // but does transaction start implicitely?
                    inTransaction = !autocommitMode;

                    if (!doCommit)
                    {
                        logger.debug("Clearing Table Map events");
                        tableEvents.clear();
                        tableEvents = new HashMap<Long, TableMapLogEvent>();
                        return new DBMSEmptyEvent(getDBMSEventId(position,
                                sessionId));
                    }
                }
                else if (logEvent.getClass() == StopLogEvent.class)
                {
                    logger.debug("Stop event extracted: ");

                    // TUC-166. MySQL writes a stop event and closes the log
                    // when the MySQL daemon shuts down cleanly. It does not
                    // always mean the server is stopped now because we could
                    // be reading an old log file. We therefore ignore them
                    // and reread which makes us treat the file like a binlog
                    // with a missing ROTATE_LOG event.
                    String stopEventId = getDBMSEventId(position, sessionId);
                    logger.info("Skipping over server stop event in log: "
                            + stopEventId);
                }
                else if (logEvent.getClass() == RotateLogEvent.class)
                {
                    String newBinlogFilename = ((RotateLogEvent) logEvent)
                            .getNewBinlogFilename();
                    logger.debug("Rotate log event: new binlog="
                            + newBinlogFilename);

                    // Slave relay logs have master rotate logs that we need
                    // to ignore. We detect these because they don't match the
                    // log file pattern.
                    if (MODE_SLAVE_RELAY.equals(binlogMode)
                            && !newBinlogFilename
                                    .startsWith(this.binlogFilePattern))
                    {
                        logger.info("Ignored superfluous master rotate log event: file="
                                + newBinlogFilename);
                    }
                    else
                    {
                        // It's real so we need to rotate the log.
                        position.close();
                        position.setFileName(((RotateLogEvent) logEvent)
                                .getNewBinlogFilename());
                        position.open();
                        // Kick off an asynchronous scan for old relay logs.
                        if (useRelayLogs)
                            purgeRelayLogs(false);
                    }
                }
                else if (logEvent.getClass() == TableMapLogEvent.class)
                {
                    logger.debug("got table map event");
                    // remember last table map event
                    TableMapLogEvent tableEvent = (TableMapLogEvent) logEvent;
                    tableEvents.put(tableEvent.getTableId(), tableEvent);
                }
                else if (logEvent instanceof RowsLogEvent)
                {
                    if (logger.isDebugEnabled())
                        logger.debug("got rows log event - event size = "
                                + ((RowsLogEvent) logEvent).getEventSize());
                    rowChangeData = new RowChangeData();
                    RowsLogEvent rowsEvent = (RowsLogEvent) logEvent;
                    TableMapLogEvent tableEvent = tableEvents.get(rowsEvent
                            .getTableId());
                    rowsEvent.processExtractedEvent(rowChangeData, tableEvent);
                    dataArray.add(rowChangeData);
                    foundRowsLogEvent = true;
                }
                else if (logEvent instanceof BeginLoadQueryLogEvent)
                {
                    BeginLoadQueryLogEvent event = (BeginLoadQueryLogEvent) logEvent;
                    if (prefetchSchemaNameLDI)
                    {
                        if (loadDataSchemas == null)
                            loadDataSchemas = new HashMap<Integer, String>();
                        loadDataSchemas.put(Integer.valueOf(event.getFileID()),
                                event.getSchemaName());
                    }
                    dataArray.add(new LoadDataFileFragment(event.getFileID(),
                            event.getData(), event.getSchemaName()));
                    doFileFragment = true;
                }
                else if (logEvent instanceof AppendBlockLogEvent)
                {
                    AppendBlockLogEvent event = (AppendBlockLogEvent) logEvent;
                    String schema = null;
                    if (prefetchSchemaNameLDI && loadDataSchemas != null)
                        schema = loadDataSchemas.get(Integer.valueOf(event
                                .getFileID()));
                    dataArray.add(new LoadDataFileFragment(event.getFileID(),
                            event.getData(), schema));
                    doFileFragment = true;
                }
。。。。。。
        catch (Exception e)
        {
            if (runtime.getExtractorFailurePolicy() == FailurePolicy.STOP)
                throw new ExtractorException(
                        "Unexpected failure while extracting event " + position,
                        e);
            else
                logger.error("Unexpected failure while extracting event "
                        + position, e);

        }
        return null;
    }

上面的方法中有个生成event的方法
，如下所示   
 // Reads the next log from the file.
    private LogEvent processFile(BinlogReader position)
            throws ReplicatorException, InterruptedException
    {
        try
        {
            // Open up the binlog if we have not done so already.
            if (!position.isOpen())
            {
                position.open();
            }
            if (logger.isDebugEnabled())
                logger.debug("extracting from pos, file: "
                        + position.getFileName() + " pos: "
                        + position.getPosition());
            long indexCheckStart = System.currentTimeMillis();

            // Read from the binlog.
            while (position.available() == 0)
            {
                // TREP-301 - If we are waiting at the end of the file we
                // must check that we are not reading a log file that is
                // missing a log-rotate record.
                if (System.currentTimeMillis() - indexCheckStart > INDEX_CHECK_INTERVAL)
                {
                    BinlogIndex bi = new BinlogIndex(binlogDir,
                            binlogFilePattern, true);
                    File nextBinlog = bi.nextBinlog(position.getFileName());
                    if (nextBinlog != null)
                    {
                        // We are stuck at the tail of one binlog with more
                        // to follow. Generate and return fake log-rotate
                        // event.
                        logger.warn("Current log file appears to be missing log-rotate event: "
                                + position.getFileName());
                        logger.info("Auto-generating log-rotate event for next binlog file: "
                                + nextBinlog.getName());
                        return new RotateLogEvent(nextBinlog.getName());
                    }

                    // Ensure relay logs are running.
                    assertRelayLogsEnabled();

                    // Update index check time.
                    indexCheckStart = System.currentTimeMillis();
                }

                // Sleep for a while.
                Thread.sleep(10);
            }

            // We can assume a V4 format description as we don't support MySQL
            // versions prior to 5.0.
            FormatDescriptionLogEvent description_event = new FormatDescriptionLogEvent(
                    4);

            // Read from the log.
            LogEvent event = LogEvent.readLogEvent(runtime, position,
                    description_event, parseStatements, useBytesForStrings,
                    prefetchSchemaNameLDI);
            position.setEventID(position.getEventID() + 1);

            return event;
        }
        catch (IOException e)
        {
            throw new MySQLExtractException("Binlog file read error: file="
                    + position.getFileName() + " offset="
                    + position.getPosition(), e);
        }
    }

然后进入到 LogEvent.readLogEvent方法，深入代码内部，可以看到如下代码

    private static LogEvent readLogEvent(boolean parseStatements,
            byte[] buffer, int eventLength,
            FormatDescriptionLogEvent descriptionEvent,
            boolean useBytesForString) throws ReplicatorException
    {
        LogEvent event = null;

        switch (buffer[MysqlBinlog.EVENT_TYPE_OFFSET])
        {
            case MysqlBinlog.QUERY_EVENT :
                event = new QueryLogEvent(buffer, eventLength,
                        descriptionEvent, parseStatements, useBytesForString);
                break;
            case MysqlBinlog.LOAD_EVENT :
                logger.warn("Skipping unsupported LOAD_EVENT");
                // ev = new Load_log_event(buf, event_len, description_event);
                break;
            case MysqlBinlog.NEW_LOAD_EVENT :
                logger.warn("Skipping unsupported NEW_LOAD_EVENT");
                // ev = new Load_log_event(buf, event_len, description_event);
                break;
            case MysqlBinlog.ROTATE_EVENT :
                event = new RotateLogEvent(buffer, eventLength,
                        descriptionEvent);
                break;
            case MysqlBinlog.SLAVE_EVENT : /* can never happen (unused event) */
                logger.warn("Skipping unsupported SLAVE_EVENT");
                // ev = new Slave_log_event(buf, event_len);
                break;
            case MysqlBinlog.CREATE_FILE_EVENT :
                logger.warn("Skipping unsupported CREATE_FILE_EVENT");
                // ev = new Create_file_log_event(buf, event_len,
                // description_event);
                break;
            case MysqlBinlog.APPEND_BLOCK_EVENT :
                if (logger.isDebugEnabled())
                    logger.debug("reading APPEND_BLOCK_EVENT");
                event = new AppendBlockLogEvent(buffer, eventLength,
                        descriptionEvent);
                break;
            case MysqlBinlog.DELETE_FILE_EVENT :
                if (logger.isDebugEnabled())
                    logger.debug("reading DELETE_FILE_EVENT");
                event = new DeleteFileLogEvent(buffer, eventLength,
                        descriptionEvent);
                break;
            case MysqlBinlog.EXEC_LOAD_EVENT :
                logger.warn("Skipping unsupported EXEC_LOAD_EVENT");
                break;
            case MysqlBinlog.START_EVENT_V3 :
                /* this is sent only by MySQL <=4.x */
                logger.warn("Skipping unsupported START_EVENT_V3");
                break;
            case MysqlBinlog.STOP_EVENT :
                event = new StopLogEvent(buffer, eventLength, descriptionEvent);
                break;
            case MysqlBinlog.INTVAR_EVENT :
                if (logger.isDebugEnabled())
                    logger.debug("extracting INTVAR_EVENT");
                event = new IntvarLogEvent(buffer, eventLength,
                        descriptionEvent);
                break;
            case MysqlBinlog.XID_EVENT :
                event = new XidLogEvent(buffer, eventLength, descriptionEvent);
                break;
            case MysqlBinlog.RAND_EVENT :
                event = new RandLogEvent(buffer, eventLength, descriptionEvent);
                break;
            case MysqlBinlog.USER_VAR_EVENT :
                event = new UserVarLogEvent(buffer, eventLength,
                        descriptionEvent);
                break;
            case MysqlBinlog.FORMAT_DESCRIPTION_EVENT :
                event = new FormatDescriptionLogEvent(buffer, eventLength,
                        descriptionEvent);
                break;
。。。。。。
default :
                logger.warn("Skipping unrecognized binlog event type "
                        + buffer[MysqlBinlog.EVENT_TYPE_OFFSET]);
        }
        return event;
    }