Example #1
0
func positionCmd(subFlags *flag.FlagSet, args []string) error {
	subFlags.Parse(args)
	if len(args) < 3 {
		return fmt.Errorf("Not enough arguments for position operation.")
	}

	pos1, err := replication.DecodePosition(args[1])
	if err != nil {
		return err
	}

	switch args[0] {
	case "equal":
		pos2, err := replication.DecodePosition(args[2])
		if err != nil {
			return err
		}
		fmt.Println(pos1.Equal(pos2))
	case "at_least":
		pos2, err := replication.DecodePosition(args[2])
		if err != nil {
			return err
		}
		fmt.Println(pos1.AtLeast(pos2))
	case "append":
		gtid, err := replication.DecodeGTID(args[2])
		if err != nil {
			return err
		}
		fmt.Println(replication.AppendGTID(pos1, gtid))
	}

	return nil
}
Example #2
0
func (rci *RowcacheInvalidator) processEvent(event *binlogdatapb.StreamEvent) error {
	defer rci.handleInvalidationError(event)
	switch event.Category {
	case binlogdatapb.StreamEvent_SE_DDL:
		log.Infof("DDL invalidation: %s", event.Sql)
		rci.handleDDLEvent(event.Sql)
	case binlogdatapb.StreamEvent_SE_DML:
		rci.handleDMLEvent(event)
	case binlogdatapb.StreamEvent_SE_ERR:
		rci.handleUnrecognizedEvent(event.Sql)
	case binlogdatapb.StreamEvent_SE_POS:
		gtid, err := replication.DecodeGTID(event.TransactionId)
		if err != nil {
			return err
		}
		rci.AppendGTID(gtid)
	default:
		log.Errorf("unknown event: %#v", event)
		rci.qe.queryServiceStats.InternalErrors.Add("Invalidation", 1)
		return nil
	}
	rci.lagSeconds.Set(time.Now().Unix() - event.Timestamp)
	return nil
}
Example #3
0
// writeRecoveryPosition will write the current GTID as the recovery position
// for the next transaction.
// We will also try to get the timestamp for the transaction. Two cases:
// - we have statements, and they start with a SET TIMESTAMP that we
//   can parse: then we update transaction_timestamp in blp_checkpoint
//   with it, and set SecondsBehindMaster to now() - transaction_timestamp
// - otherwise (the statements are probably filtered out), we leave
//   transaction_timestamp alone (keeping the old value), and we don't
//   change SecondsBehindMaster
func (blp *BinlogPlayer) writeRecoveryPosition(tx *pb.BinlogTransaction) error {
	gtid, err := replication.DecodeGTID(tx.TransactionId)
	if err != nil {
		return err
	}

	now := time.Now().Unix()

	blp.position = replication.AppendGTID(blp.position, gtid)
	updateRecovery := updateBlpCheckpoint(blp.uid, blp.position, now, tx.Timestamp)

	qr, err := blp.exec(updateRecovery)
	if err != nil {
		return fmt.Errorf("Error %v in writing recovery info %v", err, updateRecovery)
	}
	if qr.RowsAffected != 1 {
		return fmt.Errorf("Cannot update blp_recovery table, affected %v rows", qr.RowsAffected)
	}
	blp.blplStats.SetLastPosition(blp.position)
	if tx.Timestamp != 0 {
		blp.blplStats.SecondsBehindMaster.Set(now - tx.Timestamp)
	}
	return nil
}