// Test
func main() {
flag.Parse()
if *version {
fmt.Println(oplog.VERSION)
return
}
if *debug {
log.SetLevel(log.DebugLevel)
}
log.Infof("Starting oplog %s", oplog.VERSION)
ol, err := oplog.New(*mongoURL, *cappedCollectionSize)
if err != nil {
log.Fatal(err)
}
ol.ObjectURL = *objectURL
log.Infof("Listening on %s (UDP/TCP)", *listenAddr)
udpd := oplog.NewUDPDaemon(*listenAddr, ol)
go func() {
log.Fatal(udpd.Run(*maxQueuedEvents))
}()
ssed := oplog.NewSSEDaemon(*listenAddr, ol)
ssed.Password = *password
log.Fatal(ssed.Run())
}
func ExampleOpLog_Append() {
ol, err := oplog.New("mongodb://localhost/oplog", 1048576)
if err != nil {
log.Fatal(err)
}
op := oplog.NewOperation("insert", time.Now(), "123", "user", nil)
ol.Append(op)
}
func ExampleOpLog_Ingest() {
ol, err := oplog.New("mongodb://localhost/oplog", 1048576)
if err != nil {
log.Fatal(err)
}
ops := make(chan *oplog.Operation)
done := make(chan bool, 1)
go ol.Ingest(ops, nil)
// Insert a large number of operations
for i := 0; i < 1000; i++ {
ops <- oplog.NewOperation("insert", time.Now(), strconv.FormatInt(int64(i), 10), "user", nil)
}
done <- true
}
func ExampleOpLog_Tail() {
ol, err := oplog.New("mongodb://localhost/oplog", 1048576)
if err != nil {
log.Fatal(err)
}
ops := make(chan oplog.GenericEvent)
stop := make(chan bool)
// Tail all future events with no filters
go ol.Tail(nil, oplog.Filter{}, ops, stop)
// Read 100 events
for i := 0; i < 100; i++ {
op := <-ops
op.WriteTo(os.Stdout)
}
// Stop the tail
stop <- true
}
func main() {
flag.Usage = func() {
fmt.Fprintf(os.Stderr, "Usage of %s:\n", os.Args[0])
flag.PrintDefaults()
fmt.Print(" <dump file>\n")
}
flag.Parse()
if flag.NArg() != 1 {
flag.Usage()
os.Exit(2)
}
file := flag.Arg(0)
if *debug {
log.SetLevel(log.DebugLevel)
}
ol, err := oplog.New(*mongoURL, *cappedCollectionSize)
if err != nil {
log.Fatal(err)
}
createMap := make(oplog.OperationDataMap)
updateMap := make(oplog.OperationDataMap)
deleteMap := make(oplog.OperationDataMap)
var fh *os.File
if file == "-" {
fh = os.Stdin
} else {
fh, err = os.Open(file)
if err != nil {
log.Fatalf("SYNC cannot open dump file: %s", err)
}
defer fh.Close()
}
log.Debugf("SYNC loading dump")
obd := oplog.OperationData{}
scanner := bufio.NewScanner(fh)
line := 0
for scanner.Scan() {
line++
if err := json.Unmarshal(scanner.Bytes(), &obd); err != nil {
log.Fatalf("SYNC dump unmarshaling error at line %d: %s", line, err)
}
if err := obd.Validate(); err != nil {
log.Fatalf("SYNC invalid operation at line %d: %s", line, err)
}
createMap[obd.GetId()] = obd
}
if err := scanner.Err(); err != nil {
log.Fatalf("SYNC dump reading error: %s", err)
}
total := len(createMap)
// Scan the oplog db and generate the diff
log.Debugf("SYNC generating the diff")
if err := ol.Diff(createMap, updateMap, deleteMap); err != nil {
log.Fatalf("SYNC diff error: %s", err)
}
totalCreate := len(createMap)
totalUpdate := len(updateMap)
totalDelete := len(deleteMap)
log.Infof("SYNC create: %d, update: %d, delete: %d, untouched: %d",
totalCreate, totalUpdate, totalDelete, total-totalCreate-totalDelete-totalDelete)
if *dryRun {
return
}
// Generate events to fix the delta
log.Debugf("SYNC sending the delta events")
db := ol.DB()
defer db.Session.Close()
op := &oplog.Operation{Event: "create"}
genEvents := func(opMap oplog.OperationDataMap) {
for _, obd := range opMap {
op.Data = &obd
ol.Append(op, db)
}
}
log.Debugf("SYNC generating %d create events", totalCreate)
genEvents(createMap)
log.Debugf("SYNC generating %d update events", totalUpdate)
op.Event = "update"
genEvents(updateMap)
log.Debugf("SYNC generating %d delete events", totalDelete)
op.Event = "delete"
genEvents(deleteMap)
log.Debugf("SYNC done")
}
