func BlocksCollection(chBreaker chan bool, chAnswer chan string) {
defer func() {
if r := recover(); r != nil {
log.Error("daemon Recovered", r)
panic(r)
}
}()
const GoroutineName = "BlocksCollection"
d := new(daemon)
d.DCDB = DbConnect(chBreaker, chAnswer, GoroutineName)
if d.DCDB == nil {
return
}
d.goRoutineName = GoroutineName
d.chAnswer = chAnswer
d.chBreaker = chBreaker
if utils.Mobile() {
d.sleepTime = 300
} else {
d.sleepTime = 60
}
if !d.CheckInstall(chBreaker, chAnswer, GoroutineName) {
return
}
d.DCDB = DbConnect(chBreaker, chAnswer, GoroutineName)
if d.DCDB == nil {
return
}
//var cur bool
BEGIN:
for {
log.Info(GoroutineName)
MonitorDaemonCh <- []string{GoroutineName, utils.Int64ToStr(utils.Time())}
// проверим, не нужно ли нам выйти из цикла
if CheckDaemonsRestart(chBreaker, chAnswer, GoroutineName) {
break BEGIN
}
log.Debug("0")
config, err := d.GetNodeConfig()
if err != nil {
if d.dPrintSleep(err, d.sleepTime) {
break BEGIN
}
continue BEGIN
}
log.Debug("1")
err, restart := d.dbLock()
if restart {
log.Debug("restart true")
break BEGIN
}
if err != nil {
log.Debug("restart err %v", err)
if d.dPrintSleep(err, d.sleepTime) {
break BEGIN
}
continue BEGIN
}
log.Debug("2")
// если это первый запуск во время инсталяции
currentBlockId, err := d.GetBlockId()
if err != nil {
if d.unlockPrintSleep(err, d.sleepTime) {
break BEGIN
}
continue BEGIN
}
log.Info("config", config)
log.Info("currentBlockId", currentBlockId)
// на время тестов
/*if !cur {
currentBlockId = 0
cur = true
}*/
parser := new(dcparser.Parser)
parser.DCDB = d.DCDB
parser.GoroutineName = GoroutineName
if currentBlockId == 0 || *utils.StartBlockId > 0 {
/*
IsNotExistBlockChain := false
if _, err := os.Stat(*utils.Dir+"/public/blockchain"); os.IsNotExist(err) {
IsNotExistBlockChain = true
}*/
if config["first_load_blockchain"] == "file" /* && IsNotExistBlockChain*/ {
log.Info("first_load_blockchain=file")
nodeConfig, err := d.GetNodeConfig()
blockchain_url := nodeConfig["first_load_blockchain_url"]
if len(blockchain_url) == 0 {
blockchain_url = consts.BLOCKCHAIN_URL
}
log.Debug("blockchain_url: %s", blockchain_url)
// возможно сервер отдаст блокчейн не с первой попытки
var blockchainSize int64
for i := 0; i < 10; i++ {
log.Debug("blockchain_url: %s, i: %d", blockchain_url, i)
blockchainSize, err = utils.DownloadToFile(blockchain_url, *utils.Dir+"/public/blockchain", 3600, chBreaker, chAnswer, GoroutineName)
if err != nil {
log.Error("%v", utils.ErrInfo(err))
}
if blockchainSize > consts.BLOCKCHAIN_SIZE {
break
}
}
log.Debug("blockchain dw ok")
if err != nil || blockchainSize < consts.BLOCKCHAIN_SIZE {
if err != nil {
log.Error("%v", utils.ErrInfo(err))
} else {
log.Info(fmt.Sprintf("%v < %v", blockchainSize, consts.BLOCKCHAIN_SIZE))
}
if d.unlockPrintSleep(err, d.sleepTime) {
break BEGIN
}
continue BEGIN
}
first := true
/*// блокчейн мог быть загружен ранее. проверим его размер
stat, err := file.Stat()
if err != nil {
if d.unlockPrintSleep(err, d.sleepTime) { break BEGIN }
file.Close()
continue BEGIN
}
if stat.Size() < consts.BLOCKCHAIN_SIZE {
d.unlockPrintSleep(fmt.Errorf("%v < %v", stat.Size(), consts.BLOCKCHAIN_SIZE), 1)
file.Close()
continue BEGIN
}*/
log.Debug("GO!")
file, err := os.Open(*utils.Dir + "/public/blockchain")
if err != nil {
if d.unlockPrintSleep(err, d.sleepTime) {
break BEGIN
}
continue BEGIN
}
err = d.ExecSql(`UPDATE config SET current_load_blockchain = 'file'`)
if err != nil {
if d.unlockPrintSleep(err, d.sleepTime) {
break BEGIN
}
continue BEGIN
}
for {
// проверим, не нужно ли нам выйти из цикла
if CheckDaemonsRestart(chBreaker, chAnswer, GoroutineName) {
d.unlockPrintSleep(fmt.Errorf("DaemonsRestart"), 0)
break BEGIN
}
b1 := make([]byte, 5)
file.Read(b1)
dataSize := utils.BinToDec(b1)
log.Debug("dataSize", dataSize)
if dataSize > 0 {
data := make([]byte, dataSize)
file.Read(data)
//log.Debug("data %x\n", data)
blockId := utils.BinToDec(data[0:5])
if *utils.EndBlockId > 0 && blockId == *utils.EndBlockId {
if d.dPrintSleep(err, d.sleepTime) {
break BEGIN
}
file.Close()
continue BEGIN
}
log.Info("blockId", blockId)
data2 := data[5:]
length := utils.DecodeLength(&data2)
log.Debug("length", length)
//log.Debug("data2 %x\n", data2)
blockBin := utils.BytesShift(&data2, length)
//log.Debug("blockBin %x\n", blockBin)
if *utils.StartBlockId == 0 || (*utils.StartBlockId > 0 && blockId > *utils.StartBlockId) {
// парсинг блока
parser.BinaryData = blockBin
if first {
parser.CurrentVersion = consts.VERSION
first = false
}
err = parser.ParseDataFull()
if err != nil {
if d.dPrintSleep(err, d.sleepTime) {
break BEGIN
}
file.Close()
continue BEGIN
}
err = parser.InsertIntoBlockchain()
if err != nil {
if d.dPrintSleep(err, d.sleepTime) {
break BEGIN
}
file.Close()
continue BEGIN
}
// отметимся, чтобы не спровоцировать очистку таблиц
err = parser.UpdMainLock()
if err != nil {
if d.dPrintSleep(err, d.sleepTime) {
break BEGIN
}
file.Close()
continue BEGIN
}
if CheckDaemonsRestart(chBreaker, chAnswer, GoroutineName) {
if d.dPrintSleep(err, d.sleepTime) {
break BEGIN
}
file.Close()
continue BEGIN
}
}
// ненужный тут размер в конце блока данных
data = make([]byte, 5)
file.Read(data)
} else {
if d.unlockPrintSleep(err, d.sleepTime) {
break BEGIN
}
continue BEGIN
}
// utils.Sleep(1)
}
file.Close()
} else {
newBlock, err := static.Asset("static/1block.bin")
if err != nil {
if d.dPrintSleep(err, d.sleepTime) {
break BEGIN
}
continue BEGIN
}
parser.BinaryData = newBlock
parser.CurrentVersion = consts.VERSION
err = parser.ParseDataFull()
if err != nil {
if d.dPrintSleep(err, d.sleepTime) {
break BEGIN
}
continue BEGIN
}
err = parser.InsertIntoBlockchain()
if err != nil {
if d.dPrintSleep(err, d.sleepTime) {
break BEGIN
}
continue BEGIN
}
}
utils.Sleep(1)
d.dbUnlock()
continue BEGIN
}
d.dbUnlock()
err = d.ExecSql(`UPDATE config SET current_load_blockchain = 'nodes'`)
if err != nil {
if d.unlockPrintSleep(err, d.sleepTime) {
break BEGIN
}
continue BEGIN
}
myConfig, err := d.OneRow("SELECT local_gate_ip, static_node_user_id FROM config").String()
if err != nil {
if d.dPrintSleep(err, d.sleepTime) {
break BEGIN
}
continue
}
var hosts []map[string]string
var nodeHost string
var dataTypeMaxBlockId, dataTypeBlockBody int64
if len(myConfig["local_gate_ip"]) > 0 {
hosts = append(hosts, map[string]string{"host": myConfig["local_gate_ip"], "user_id": myConfig["static_node_user_id"]})
nodeHost, err = d.Single("SELECT tcp_host FROM miners_data WHERE user_id = ?", myConfig["static_node_user_id"]).String()
if err != nil {
if d.dPrintSleep(err, d.sleepTime) {
break BEGIN
}
continue
}
dataTypeMaxBlockId = 9
dataTypeBlockBody = 8
//getBlockScriptName = "ajax?controllerName=protectedGetBlock";
//addNodeHost = "&nodeHost="+nodeHost;
} else {
// получим список нодов, с кем установлено рукопожатие
hosts, err = d.GetAll("SELECT * FROM nodes_connection", -1)
if err != nil {
if d.dPrintSleep(err, d.sleepTime) {
break BEGIN
}
continue
}
dataTypeMaxBlockId = 10
dataTypeBlockBody = 7
//getBlockScriptName = "ajax?controllerName=getBlock";
//addNodeHost = "";
}
log.Info("%v", hosts)
if len(hosts) == 0 {
if d.dPrintSleep(err, 1) {
break BEGIN
}
continue
}
maxBlockId := int64(1)
maxBlockIdHost := ""
var maxBlockIdUserId int64
// получим максимальный номер блока
for i := 0; i < len(hosts); i++ {
if CheckDaemonsRestart(chBreaker, chAnswer, GoroutineName) {
break BEGIN
}
conn, err := utils.TcpConn(hosts[i]["host"])
if err != nil {
if d.dPrintSleep(err, 1) {
break BEGIN
}
continue
}
// шлем тип данных
_, err = conn.Write(utils.DecToBin(dataTypeMaxBlockId, 1))
if err != nil {
conn.Close()
if d.dPrintSleep(err, 1) {
break BEGIN
}
continue
}
if len(nodeHost) > 0 { // защищенный режим
err = utils.WriteSizeAndData([]byte(nodeHost), conn)
if err != nil {
conn.Close()
if d.dPrintSleep(err, d.sleepTime) {
break BEGIN
}
continue
}
}
// в ответ получаем номер блока
blockIdBin := make([]byte, 4)
_, err = conn.Read(blockIdBin)
if err != nil {
conn.Close()
if d.dPrintSleep(err, 1) {
break BEGIN
}
continue
}
conn.Close()
id := utils.BinToDec(blockIdBin)
if id > maxBlockId || i == 0 {
maxBlockId = id
maxBlockIdHost = hosts[i]["host"]
maxBlockIdUserId = utils.StrToInt64(hosts[i]["user_id"])
}
if CheckDaemonsRestart(chBreaker, chAnswer, GoroutineName) {
utils.Sleep(1)
break BEGIN
}
}
// получим наш текущий имеющийся номер блока
// ждем, пока разлочится и лочим сами, чтобы не попасть в тот момент, когда данные из блока уже занесены в БД, а info_block еще не успел обновиться
err, restart = d.dbLock()
if restart {
break BEGIN
}
if err != nil {
if d.dPrintSleep(err, d.sleepTime) {
break BEGIN
}
continue BEGIN
}
currentBlockId, err = d.Single("SELECT block_id FROM info_block").Int64()
if err != nil {
if d.unlockPrintSleep(utils.ErrInfo(err), d.sleepTime) {
break BEGIN
}
continue
}
log.Info("currentBlockId", currentBlockId, "maxBlockId", maxBlockId)
if maxBlockId <= currentBlockId {
if d.unlockPrintSleep(utils.ErrInfo(errors.New("maxBlockId <= currentBlockId")), d.sleepTime) {
break BEGIN
}
continue
}
fmt.Printf("\nnode: %s\n", maxBlockIdHost)
// в цикле собираем блоки, пока не дойдем до максимального
for blockId := currentBlockId + 1; blockId < maxBlockId+1; blockId++ {
d.UpdMainLock()
if CheckDaemonsRestart(chBreaker, chAnswer, GoroutineName) {
if d.unlockPrintSleep(utils.ErrInfo(err), d.sleepTime) {
break BEGIN
}
break BEGIN
}
variables, err := d.GetAllVariables()
if err != nil {
if d.unlockPrintSleep(utils.ErrInfo(err), d.sleepTime) {
break BEGIN
}
continue BEGIN
}
// качаем тело блока с хоста maxBlockIdHost
binaryBlock, err := utils.GetBlockBody(maxBlockIdHost, blockId, dataTypeBlockBody, nodeHost)
if len(binaryBlock) == 0 {
// баним на 1 час хост, который дал нам пустой блок, хотя должен был дать все до максимального
// для тестов убрал, потом вставить.
//nodes_ban ($db, $max_block_id_user_id, substr($binary_block, 0, 512)."\n".__FILE__.', '.__LINE__.', '. __FUNCTION__.', '.__CLASS__.', '. __METHOD__);
//p.NodesBan(maxBlockIdUserId, "len(binaryBlock) == 0")
if d.unlockPrintSleep(utils.ErrInfo(err), d.sleepTime) {
break BEGIN
}
continue BEGIN
}
binaryBlockFull := binaryBlock
utils.BytesShift(&binaryBlock, 1) // уберем 1-й байт - тип (блок/тр-я)
// распарсим заголовок блока
blockData := utils.ParseBlockHeader(&binaryBlock)
log.Info("blockData: %v, blockId: %v", blockData, blockId)
// если существуют глючная цепочка, тот тут мы её проигнорируем
badBlocks_, err := d.Single("SELECT bad_blocks FROM config").Bytes()
if err != nil {
if d.unlockPrintSleep(utils.ErrInfo(err), d.sleepTime) {
break BEGIN
}
continue BEGIN
}
badBlocks := make(map[int64]string)
if len(badBlocks_) > 0 {
err = json.Unmarshal(badBlocks_, &badBlocks)
if err != nil {
if d.unlockPrintSleep(utils.ErrInfo(err), d.sleepTime) {
break BEGIN
}
continue BEGIN
}
}
if badBlocks[blockData.BlockId] == string(utils.BinToHex(blockData.Sign)) {
d.NodesBan(maxBlockIdUserId, fmt.Sprintf("bad_block = %v => %v", blockData.BlockId, badBlocks[blockData.BlockId]))
if d.unlockPrintSleep(utils.ErrInfo(err), d.sleepTime) {
break BEGIN
}
continue BEGIN
}
// размер блока не может быть более чем max_block_size
if currentBlockId > 1 {
if int64(len(binaryBlock)) > variables.Int64["max_block_size"] {
d.NodesBan(maxBlockIdUserId, fmt.Sprintf(`len(binaryBlock) > variables.Int64["max_block_size"] %v > %v`, len(binaryBlock), variables.Int64["max_block_size"]))
if d.unlockPrintSleep(utils.ErrInfo(err), d.sleepTime) {
break BEGIN
}
continue BEGIN
}
}
if blockData.BlockId != blockId {
d.NodesBan(maxBlockIdUserId, fmt.Sprintf(`blockData.BlockId != blockId %v > %v`, blockData.BlockId, blockId))
if d.unlockPrintSleep(utils.ErrInfo(err), d.sleepTime) {
break BEGIN
}
continue BEGIN
}
// нам нужен хэш предыдущего блока, чтобы проверить подпись
prevBlockHash := ""
if blockId > 1 {
prevBlockHash, err = d.Single("SELECT hash FROM block_chain WHERE id = ?", blockId-1).String()
if err != nil {
if d.unlockPrintSleep(utils.ErrInfo(err), d.sleepTime) {
break BEGIN
}
continue BEGIN
}
prevBlockHash = string(utils.BinToHex([]byte(prevBlockHash)))
} else {
prevBlockHash = "0"
}
first := false
if blockId == 1 {
first = true
}
// нам нужен меркель-рут текущего блока
mrklRoot, err := utils.GetMrklroot(binaryBlock, variables, first)
if err != nil {
d.NodesBan(maxBlockIdUserId, fmt.Sprintf(`%v`, err))
if d.unlockPrintSleep(utils.ErrInfo(err), d.sleepTime) {
break BEGIN
}
continue BEGIN
}
// публичный ключ того, кто этот блок сгенерил
nodePublicKey, err := d.GetNodePublicKey(blockData.UserId)
if err != nil {
if d.unlockPrintSleep(utils.ErrInfo(err), d.sleepTime) {
break BEGIN
}
continue BEGIN
}
// SIGN от 128 байта до 512 байт. Подпись от TYPE, BLOCK_ID, PREV_BLOCK_HASH, TIME, USER_ID, LEVEL, MRKL_ROOT
forSign := fmt.Sprintf("0,%v,%v,%v,%v,%v,%s", blockData.BlockId, prevBlockHash, blockData.Time, blockData.UserId, blockData.Level, mrklRoot)
// проверяем подпись
if !first {
_, err = utils.CheckSign([][]byte{nodePublicKey}, forSign, blockData.Sign, true)
}
// качаем предыдущие блоки до тех пор, пока отличается хэш предыдущего.
// другими словами, пока подпись с prevBlockHash будет неверной, т.е. пока что-то есть в $error
if err != nil {
log.Error("%v", utils.ErrInfo(err))
if blockId < 1 {
if d.unlockPrintSleep(utils.ErrInfo(err), d.sleepTime) {
break BEGIN
}
continue BEGIN
}
// нужно привести данные в нашей БД в соответствие с данными у того, у кого качаем более свежий блок
//func (p *Parser) GetOldBlocks (userId, blockId int64, host string, hostUserId int64, goroutineName, getBlockScriptName, addNodeHost string) error {
err := parser.GetOldBlocks(blockData.UserId, blockId-1, maxBlockIdHost, maxBlockIdUserId, GoroutineName, dataTypeBlockBody, nodeHost)
if err != nil {
log.Error("%v", err)
d.NodesBan(maxBlockIdUserId, fmt.Sprintf(`blockId: %v / %v`, blockId, err))
if d.unlockPrintSleep(utils.ErrInfo(err), d.sleepTime) {
break BEGIN
}
continue BEGIN
}
} else {
log.Info("plug found blockId=%v\n", blockId)
// получим наши транзакции в 1 бинарнике, просто для удобства
var transactions []byte
utils.WriteSelectiveLog("SELECT data FROM transactions WHERE verified = 1 AND used = 0")
rows, err := d.Query("SELECT data FROM transactions WHERE verified = 1 AND used = 0")
if err != nil {
utils.WriteSelectiveLog(err)
if d.unlockPrintSleep(utils.ErrInfo(err), d.sleepTime) {
break BEGIN
}
continue BEGIN
}
for rows.Next() {
var data []byte
err = rows.Scan(&data)
utils.WriteSelectiveLog(utils.BinToHex(data))
if err != nil {
rows.Close()
if d.unlockPrintSleep(utils.ErrInfo(err), d.sleepTime) {
break BEGIN
}
continue BEGIN
}
transactions = append(transactions, utils.EncodeLengthPlusData(data)...)
}
rows.Close()
if len(transactions) > 0 {
// отмечаем, что эти тр-ии теперь нужно проверять по новой
utils.WriteSelectiveLog("UPDATE transactions SET verified = 0 WHERE verified = 1 AND used = 0")
affect, err := d.ExecSqlGetAffect("UPDATE transactions SET verified = 0 WHERE verified = 1 AND used = 0")
if err != nil {
utils.WriteSelectiveLog(err)
if d.unlockPrintSleep(utils.ErrInfo(err), d.sleepTime) {
break BEGIN
}
continue BEGIN
}
utils.WriteSelectiveLog("affect: " + utils.Int64ToStr(affect))
// откатываем по фронту все свежие тр-ии
parser.BinaryData = transactions
err = parser.ParseDataRollbackFront(false)
if err != nil {
utils.Sleep(1)
continue BEGIN
}
}
err = parser.RollbackTransactionsTestblock(true)
if err != nil {
if d.unlockPrintSleep(utils.ErrInfo(err), d.sleepTime) {
break BEGIN
}
continue BEGIN
}
err = d.ExecSql("DELETE FROM testblock")
if err != nil {
if d.unlockPrintSleep(utils.ErrInfo(err), d.sleepTime) {
break BEGIN
}
continue BEGIN
}
}
// теперь у нас в таблицах всё тоже самое, что у нода, у которого качаем блок
// и можем этот блок проверить и занести в нашу БД
parser.BinaryData = binaryBlockFull
err = parser.ParseDataFull()
if err == nil {
err = parser.InsertIntoBlockchain()
if err != nil {
if d.unlockPrintSleep(utils.ErrInfo(err), d.sleepTime) {
break BEGIN
}
continue BEGIN
}
}
// начинаем всё с начала уже с другими нодами. Но у нас уже могут быть новые блоки до $block_id, взятые от нода, которого с в итоге мы баним
if err != nil {
d.NodesBan(maxBlockIdUserId, fmt.Sprintf(`blockId: %v / %v`, blockId, err))
if d.unlockPrintSleep(utils.ErrInfo(err), d.sleepTime) {
break BEGIN
}
continue BEGIN
}
}
d.dbUnlock()
if d.dSleep(d.sleepTime) {
break BEGIN
}
}
log.Debug("break BEGIN %v", GoroutineName)
}
func (d *daemon) DisseminatorType1(host string, userId int64, node_public_key string, toBeSent []byte, dataType int64) {
log.Debug("host %v / userId %v", host, userId)
// шлем данные указанному хосту
conn, err := utils.TcpConn(host)
if err != nil {
log.Error("%v", utils.ErrInfo(err))
return
}
defer conn.Close()
randTestblockHash, err := d.Single("SELECT head_hash FROM queue_testblock").String()
if err != nil {
log.Error("%v", utils.ErrInfo(err))
return
}
// получаем IV + ключ + зашифрованный текст
dataToBeSent, key, iv, err := utils.EncryptData(toBeSent, []byte(node_public_key), randTestblockHash)
log.Debug("key: %s", key)
log.Debug("iv: %s", iv)
if err != nil {
log.Error("%v", utils.ErrInfo(err))
return
}
// вначале шлем тип данных, чтобы принимающая сторона могла понять, как именно надо обрабатывать присланные данные
n, err := conn.Write(utils.DecToBin(dataType, 1))
if err != nil {
log.Error("%v", utils.ErrInfo(err))
return
}
log.Debug("n: %x", n)
// т.к. на приеме может быть пул, то нужно дописать в начало user_id, чьим нодовским ключем шифруем
dataToBeSent = append(utils.DecToBin(userId, 5), dataToBeSent...)
log.Debug("dataToBeSent: %x", dataToBeSent)
// в 4-х байтах пишем размер данных, которые пошлем далее
size := utils.DecToBin(len(dataToBeSent), 4)
n, err = conn.Write(size)
if err != nil {
log.Error("%v", utils.ErrInfo(err))
return
}
log.Debug("n: %x", n)
n, err = conn.Write(dataToBeSent)
if err != nil {
log.Error("%v", utils.ErrInfo(err))
return
}
log.Debug("n: %d / size: %v / len: %d", n, utils.BinToDec(size), len(dataToBeSent))
// в ответ получаем размер данных, которые нам хочет передать сервер
buf := make([]byte, 4)
n, err = conn.Read(buf)
if err != nil {
log.Error("%v", utils.ErrInfo(err))
return
}
log.Debug("n: %x", n)
dataSize := utils.BinToDec(buf)
log.Debug("dataSize %d", dataSize)
// и если данных менее 1мб, то получаем их
if dataSize < 1048576 {
encBinaryTxHashes := make([]byte, dataSize)
_, err = io.ReadFull(conn, encBinaryTxHashes)
if err != nil {
log.Error("%v", utils.ErrInfo(err))
return
}
// разбираем полученные данные
binaryTxHashes, err := utils.DecryptCFB(iv, encBinaryTxHashes, key)
if err != nil {
log.Error("%v", utils.ErrInfo(err))
return
}
log.Debug("binaryTxHashes %x", binaryTxHashes)
var binaryTx []byte
for {
// Разбираем список транзакций
txHash := make([]byte, 16)
if len(binaryTxHashes) >= 16 {
txHash = utils.BytesShift(&binaryTxHashes, 16)
}
txHash = utils.BinToHex(txHash)
log.Debug("txHash %s", txHash)
utils.WriteSelectiveLog("SELECT data FROM transactions WHERE hex(hash) = " + string(txHash))
tx, err := d.Single("SELECT data FROM transactions WHERE hex(hash) = ?", txHash).Bytes()
log.Debug("tx %x", tx)
if err != nil {
utils.WriteSelectiveLog(err)
log.Error("%v", utils.ErrInfo(err))
return
}
utils.WriteSelectiveLog("tx: " + string(utils.BinToHex(tx)))
if len(tx) > 0 {
binaryTx = append(binaryTx, utils.EncodeLengthPlusData(tx)...)
}
if len(binaryTxHashes) == 0 {
break
}
}
log.Debug("binaryTx %x", binaryTx)
// шифруем тр-ии. Вначале encData добавляется IV
encData, _, err := utils.EncryptCFB(binaryTx, key, iv)
if err != nil {
log.Error("%v", utils.ErrInfo(err))
return
}
log.Debug("encData %x", encData)
// шлем серверу
// в первых 4-х байтах пишем размер данных, которые пошлем далее
size := utils.DecToBin(len(encData), 4)
_, err = conn.Write(size)
if err != nil {
log.Error("%v", utils.ErrInfo(err))
return
}
// далее шлем сами данные
_, err = conn.Write(encData)
if err != nil {
log.Error("%v", utils.ErrInfo(err))
return
}
}
}
/*
* просто шлем всем, кто есть в nodes_connection хэши блока и тр-ий
* если мы не майнер, то шлем всю тр-ию целиком, блоки слать не можем
* если майнер - то шлем только хэши, т.к. у нас есть хост, откуда всё можно скачать
* */
func Disseminator(chBreaker chan bool, chAnswer chan string) {
defer func() {
if r := recover(); r != nil {
log.Error("daemon Recovered", r)
panic(r)
}
}()
const GoroutineName = "Disseminator"
d := new(daemon)
d.DCDB = DbConnect(chBreaker, chAnswer, GoroutineName)
if d.DCDB == nil {
return
}
d.goRoutineName = GoroutineName
d.chAnswer = chAnswer
d.chBreaker = chBreaker
if utils.Mobile() {
d.sleepTime = 300
} else {
d.sleepTime = 1
}
if !d.CheckInstall(chBreaker, chAnswer, GoroutineName) {
return
}
d.DCDB = DbConnect(chBreaker, chAnswer, GoroutineName)
if d.DCDB == nil {
return
}
BEGIN:
for {
log.Info(GoroutineName)
MonitorDaemonCh <- []string{GoroutineName, utils.Int64ToStr(utils.Time())}
// проверим, не нужно ли нам выйти из цикла
if CheckDaemonsRestart(chBreaker, chAnswer, GoroutineName) {
break BEGIN
}
var hosts []map[string]string
var nodeData map[string]string
nodeConfig, err := d.GetNodeConfig()
if len(nodeConfig["local_gate_ip"]) == 0 {
// обычный режим
hosts, err = d.GetAll(`
SELECT miners_data.user_id, miners_data.tcp_host as host, node_public_key
FROM nodes_connection
LEFT JOIN miners_data ON nodes_connection.user_id = miners_data.user_id
`, -1)
if err != nil {
if d.dPrintSleep(err, d.sleepTime) {
break BEGIN
}
continue
}
if len(hosts) == 0 {
if d.dSleep(d.sleepTime) {
break BEGIN
}
log.Debug("len(hosts) == 0")
continue
}
} else {
// защищенный режим
nodeData, err = d.OneRow("SELECT node_public_key, tcp_host FROM miners_data WHERE user_id = ?", nodeConfig["static_node_user_id"]).String()
if err != nil {
if d.dPrintSleep(err, d.sleepTime) {
break BEGIN
}
continue
}
hosts = append(hosts, map[string]string{"host": nodeConfig["local_gate_ip"], "node_public_key": nodeData["node_public_key"], "user_id": nodeConfig["static_node_user_id"]})
}
myUsersIds, err := d.GetMyUsersIds(false, false)
if err != nil {
if d.dPrintSleep(err, d.sleepTime) {
break BEGIN
}
continue
}
myMinersIds, err := d.GetMyMinersIds(myUsersIds)
if err != nil {
if d.dPrintSleep(err, d.sleepTime) {
break BEGIN
}
continue
}
log.Debug("%v", myUsersIds)
log.Debug("%v", myMinersIds)
// если среди тр-ий есть смена нодовского ключа, то слать через отправку хэшей с последющей отдачей данных может не получиться
// т.к. при некорректном нодовском ключе придет зашифрованый запрос на отдачу данных, а мы его не сможем расшифровать т.к. ключ у нас неверный
var changeNodeKey int64
if len(myUsersIds) > 0 {
changeNodeKey, err = d.Single(`
SELECT count(*)
FROM transactions
WHERE type = ? AND
user_id IN (`+strings.Join(utils.SliceInt64ToString(myUsersIds), ",")+`)
`, utils.TypeInt("ChangeNodeKey")).Int64()
if err != nil {
if d.dPrintSleep(err, d.sleepTime) {
break BEGIN
}
continue BEGIN
}
}
var dataType int64 // это тип для того, чтобы принимающая сторона могла понять, как именно надо обрабатывать присланные данные
// если я майнер и работаю в обычном режиме, то должен слать хэши
if len(myMinersIds) > 0 && len(nodeConfig["local_gate_ip"]) == 0 && changeNodeKey == 0 {
log.Debug("0")
dataType = 1
// определим, от кого будем слать
r := utils.RandInt(0, len(myMinersIds))
myMinerId := myMinersIds[r]
myUserId, err := d.Single("SELECT user_id FROM miners_data WHERE miner_id = ?", myMinerId).Int64()
if err != nil {
if d.dPrintSleep(err, d.sleepTime) {
break BEGIN
}
continue BEGIN
}
// возьмем хэш текущего блока и номер блока
// для теста ролбеков отключим на время
data, err := d.OneRow("SELECT block_id, hash, head_hash FROM info_block WHERE sent = 0").Bytes()
if err != nil {
if d.dPrintSleep(err, d.sleepTime) {
break BEGIN
}
continue BEGIN
}
err = d.ExecSql("UPDATE info_block SET sent = 1")
if err != nil {
if d.dPrintSleep(err, d.sleepTime) {
break BEGIN
}
continue BEGIN
}
/*
* Составляем данные на отправку
* */
// 5 байт = наш user_id. Но они будут не первые, т.к. m_curl допишет вперед user_id получателя (нужно для пулов)
toBeSent := utils.DecToBin(myUserId, 5)
if len(data) > 0 { // блок
// если 5-й байт = 0, то на приемнике будем читать блок, если = 1 , то сразу хэши тр-ий
toBeSent = append(toBeSent, utils.DecToBin(0, 1)...)
toBeSent = append(toBeSent, utils.DecToBin(utils.BytesToInt64(data["block_id"]), 3)...)
toBeSent = append(toBeSent, data["hash"]...)
toBeSent = append(toBeSent, data["head_hash"]...)
err = d.ExecSql("UPDATE info_block SET sent = 1")
if err != nil {
if d.dPrintSleep(err, d.sleepTime) {
break BEGIN
}
continue BEGIN
}
} else { // тр-ии без блока
toBeSent = append(toBeSent, utils.DecToBin(1, 1)...)
}
// возьмем хэши тр-ий
//utils.WriteSelectiveLog("SELECT hash, high_rate FROM transactions WHERE sent = 0 AND for_self_use = 0")
transactions, err := d.GetAll("SELECT hash, high_rate FROM transactions WHERE sent = 0 AND for_self_use = 0", -1)
if err != nil {
utils.WriteSelectiveLog(err)
if d.dPrintSleep(err, d.sleepTime) {
break BEGIN
}
continue BEGIN
}
// нет ни транзакций, ни блока для отправки...
if len(transactions) == 0 && len(toBeSent) < 10 {
//utils.WriteSelectiveLog("len(transactions) == 0")
//log.Debug("len(transactions) == 0")
if d.dSleep(d.sleepTime) {
break BEGIN
}
log.Debug("len(transactions) == 0 && len(toBeSent) == 0")
continue BEGIN
}
for _, data := range transactions {
hexHash := utils.BinToHex([]byte(data["hash"]))
toBeSent = append(toBeSent, utils.DecToBin(utils.StrToInt64(data["high_rate"]), 1)...)
toBeSent = append(toBeSent, []byte(data["hash"])...)
utils.WriteSelectiveLog("UPDATE transactions SET sent = 1 WHERE hex(hash) = " + string(hexHash))
affect, err := d.ExecSqlGetAffect("UPDATE transactions SET sent = 1 WHERE hex(hash) = ?", hexHash)
if err != nil {
utils.WriteSelectiveLog(err)
if d.dPrintSleep(err, d.sleepTime) {
break BEGIN
}
continue BEGIN
}
utils.WriteSelectiveLog("affect: " + utils.Int64ToStr(affect))
}
// отправляем блок и хэши тр-ий, если есть что отправлять
if len(toBeSent) > 0 {
for _, host := range hosts {
go d.DisseminatorType1(host["host"], utils.StrToInt64(host["user_id"]), host["node_public_key"], toBeSent, dataType)
}
}
} else {
log.Debug("1")
var remoteNodeHost string
// если просто юзер или работаю в защищенном режиме, то шлю тр-ии целиком. слать блоки не имею права.
if len(nodeConfig["local_gate_ip"]) > 0 {
dataType = 3
remoteNodeHost = nodeData["host"]
} else {
dataType = 2
remoteNodeHost = ""
}
log.Debug("dataType: %d", dataType)
var toBeSent []byte // сюда пишем все тр-ии, которые будем слать другим нодам
// возьмем хэши и сами тр-ии
utils.WriteSelectiveLog("SELECT hash, data FROM transactions WHERE sent = 0")
rows, err := d.Query("SELECT hash, data FROM transactions WHERE sent = 0")
if err != nil {
utils.WriteSelectiveLog(err)
if d.dPrintSleep(err, d.sleepTime) {
break BEGIN
}
continue BEGIN
}
for rows.Next() {
var hash, data []byte
err = rows.Scan(&hash, &data)
if err != nil {
rows.Close()
if d.dPrintSleep(err, d.sleepTime) {
break BEGIN
}
continue BEGIN
}
log.Debug("hash %x", hash)
hashHex := utils.BinToHex(hash)
utils.WriteSelectiveLog("UPDATE transactions SET sent = 1 WHERE hex(hash) = " + string(hashHex))
affect, err := d.ExecSqlGetAffect("UPDATE transactions SET sent = 1 WHERE hex(hash) = ?", hashHex)
if err != nil {
utils.WriteSelectiveLog(err)
rows.Close()
if d.dPrintSleep(err, d.sleepTime) {
break BEGIN
}
continue BEGIN
}
utils.WriteSelectiveLog("affect: " + utils.Int64ToStr(affect))
toBeSent = append(toBeSent, data...)
}
rows.Close()
// шлем тр-ии
if len(toBeSent) > 0 {
for _, host := range hosts {
userId := utils.StrToInt64(host["user_id"])
go func(host string, userId int64, node_public_key string) {
log.Debug("host %v / userId %v", host, userId)
conn, err := utils.TcpConn(host)
if err != nil {
log.Error("%v", utils.ErrInfo(err))
return
}
defer conn.Close()
randTestblockHash, err := d.Single("SELECT head_hash FROM queue_testblock").String()
if err != nil {
log.Error("%v", utils.ErrInfo(err))
return
}
// получаем IV + ключ + зашифрованный текст
encryptedData, _, _, err := utils.EncryptData(toBeSent, []byte(node_public_key), randTestblockHash)
if err != nil {
log.Error("%v", utils.ErrInfo(err))
return
}
// вначале шлем тип данных, чтобы принимающая сторона могла понять, как именно надо обрабатывать присланные данные
_, err = conn.Write(utils.DecToBin(dataType, 1))
if err != nil {
log.Error("%v", utils.ErrInfo(err))
return
}
// т.к. на приеме может быть пул, то нужно дописать в начало user_id, чьим нодовским ключем шифруем
/*_, err = conn.Write(utils.DecToBin(userId, 5))
if err != nil {
log.Error("%v", utils.ErrInfo(err))
return
}*/
encryptedData = append(utils.DecToBin(userId, 5), encryptedData...)
// это может быть защищенное локальное соедниение (dataType = 3) и принимающему ноду нужно знать, куда дальше слать данные и чьим они зашифрованы ключем
if len(remoteNodeHost) > 0 {
/*
_, err = conn.Write([]byte(remoteNodeHost))
if err != nil {
log.Error("%v", utils.ErrInfo(err))
return
}*/
encryptedData = append([]byte(remoteNodeHost), encryptedData...)
}
log.Debug("encryptedData %x", encryptedData)
// в 4-х байтах пишем размер данных, которые пошлем далее
size := utils.DecToBin(len(encryptedData), 4)
_, err = conn.Write(size)
if err != nil {
log.Error("%v", utils.ErrInfo(err))
return
}
// далее шлем сами данные
_, err = conn.Write(encryptedData)
if err != nil {
log.Error("%v", utils.ErrInfo(err))
return
}
}(host["host"], userId, host["node_public_key"])
}
}
}
d.dbUnlock()
if d.dSleep(d.sleepTime) {
break BEGIN
}
}
log.Debug("break BEGIN %v", GoroutineName)
}
/**
* Занесение данных из блока в БД
* используется только в testblock_is_ready
*/
func (p *Parser) ParseDataFront() error {
p.TxIds = []string{}
p.dataPre()
if p.dataType == 0 {
// инфа о предыдущем блоке (т.е. последнем занесенном)
err := p.GetInfoBlock()
if err != nil {
return p.ErrInfo(err)
}
utils.WriteSelectiveLog("DELETE FROM transactions WHERE used=1")
affect, err := p.ExecSqlGetAffect("DELETE FROM transactions WHERE used = 1")
if err != nil {
utils.WriteSelectiveLog(err)
return p.ErrInfo(err)
}
utils.WriteSelectiveLog("affect: " + utils.Int64ToStr(affect))
// разбор блока
err = p.ParseBlock()
if err != nil {
return utils.ErrInfo(err)
}
p.Variables, err = p.GetAllVariables()
if err != nil {
return utils.ErrInfo(err)
}
//меркель рут нужен для updblockinfo()
p.MrklRoot, err = utils.GetMrklroot(p.BinaryData, p.Variables, false)
if err != nil {
return utils.ErrInfo(err)
}
if len(p.BinaryData) > 0 {
for {
transactionSize := utils.DecodeLength(&p.BinaryData)
if len(p.BinaryData) == 0 {
return utils.ErrInfo(fmt.Errorf("empty BinaryData"))
}
// отчекрыжим одну транзакцию от списка транзакций
transactionBinaryData := utils.BytesShift(&p.BinaryData, transactionSize)
transactionBinaryDataFull := transactionBinaryData
p.TxHash = utils.Md5(transactionBinaryData)
log.Debug("p.TxHash", p.TxHash)
p.TxSlice, err = p.ParseTransaction(&transactionBinaryData)
log.Debug("p.TxSlice", p.TxSlice)
if err != nil {
return utils.ErrInfo(err)
}
// txSlice[3] могут подсунуть пустой
if len(p.TxSlice) > 3 {
if !utils.CheckInputData(p.TxSlice[3], "int64") {
return utils.ErrInfo(fmt.Errorf("empty user_id"))
}
} else {
return utils.ErrInfo(fmt.Errorf("empty user_id"))
}
// проверим, есть ли такой тип тр-ий
_, ok := consts.TxTypes[utils.BytesToInt(p.TxSlice[1])]
if !ok {
return utils.ErrInfo(fmt.Errorf("nonexistent type"))
}
p.TxMap = map[string][]byte{}
// для статы
p.TxIds = append(p.TxIds, string(p.TxSlice[1]))
MethodName := consts.TxTypes[utils.BytesToInt(p.TxSlice[1])]
log.Debug("MethodName", MethodName+"Init")
err_ := utils.CallMethod(p, MethodName+"Init")
if _, ok := err_.(error); ok {
log.Debug("error: %v", err)
return utils.ErrInfo(err_.(error))
}
log.Debug("MethodName", MethodName)
err_ = utils.CallMethod(p, MethodName)
if _, ok := err_.(error); ok {
log.Debug("error: %v", err)
return utils.ErrInfo(err_.(error))
}
utils.WriteSelectiveLog("UPDATE transactions SET used=1 WHERE hex(hash) = " + string(utils.Md5(transactionBinaryDataFull)))
affect, err := p.ExecSqlGetAffect("UPDATE transactions SET used=1 WHERE hex(hash) = ?", utils.Md5(transactionBinaryDataFull))
if err != nil {
utils.WriteSelectiveLog(err)
return utils.ErrInfo(err)
}
utils.WriteSelectiveLog("affect: " + utils.Int64ToStr(affect))
// даем юзеру понять, что его тр-ия попала в блок
err = p.ExecSql("UPDATE transactions_status SET block_id = ? WHERE hex(hash) = ?", p.BlockData.BlockId, utils.Md5(transactionBinaryDataFull))
if err != nil {
return utils.ErrInfo(err)
}
if len(p.BinaryData) == 0 {
break
}
}
}
p.UpdBlockInfo()
p.InsertIntoBlockchain()
} else {
return utils.ErrInfo(fmt.Errorf("incorrect type"))
}
return nil
}
/**
фронт. проверка + занесение данных из блока в таблицы и info_block
*/
func (p *Parser) ParseDataFull() error {
p.TxIds = []string{}
p.dataPre()
if p.dataType != 0 { // парсим только блоки
return utils.ErrInfo(fmt.Errorf("incorrect dataType"))
}
var err error
p.Variables, err = p.GetAllVariables()
if err != nil {
return utils.ErrInfo(err)
}
//if len(p.BinaryData) > 500000 {
// ioutil.WriteFile("block-"+string(utils.DSha256(p.BinaryData)), p.BinaryData, 0644)
//}
err = p.ParseBlock()
if err != nil {
return utils.ErrInfo(err)
}
// проверим данные, указанные в заголовке блока
err = p.CheckBlockHeader()
if err != nil {
return utils.ErrInfo(err)
}
utils.WriteSelectiveLog("DELETE FROM transactions WHERE used = 1")
afect, err := p.ExecSqlGetAffect("DELETE FROM transactions WHERE used = 1")
if err != nil {
utils.WriteSelectiveLog(err)
return utils.ErrInfo(err)
}
utils.WriteSelectiveLog("afect: " + utils.Int64ToStr(afect))
txCounter := make(map[int64]int64)
p.fullTxBinaryData = p.BinaryData
var txForRollbackTo []byte
if len(p.BinaryData) > 0 {
for {
// обработка тр-ий может занять много времени, нужно отметиться
p.UpdDaemonTime(p.GoroutineName)
p.halfRollback = false
log.Debug("&p.BinaryData", p.BinaryData)
transactionSize := utils.DecodeLength(&p.BinaryData)
if len(p.BinaryData) == 0 {
return utils.ErrInfo(fmt.Errorf("empty BinaryData"))
}
// отчекрыжим одну транзакцию от списка транзакций
//log.Debug("++p.BinaryData=%x\n", p.BinaryData)
//log.Debug("transactionSize", transactionSize)
transactionBinaryData := utils.BytesShift(&p.BinaryData, transactionSize)
transactionBinaryDataFull := transactionBinaryData
//ioutil.WriteFile("/tmp/dctx", transactionBinaryDataFull, 0644)
//ioutil.WriteFile("/tmp/dctxhash", utils.Md5(transactionBinaryDataFull), 0644)
// добавляем взятую тр-ию в набор тр-ий для RollbackTo, в котором пойдем в обратном порядке
txForRollbackTo = append(txForRollbackTo, utils.EncodeLengthPlusData(transactionBinaryData)...)
//log.Debug("transactionBinaryData: %x\n", transactionBinaryData)
//log.Debug("txForRollbackTo: %x\n", txForRollbackTo)
err = p.CheckLogTx(transactionBinaryDataFull)
if err != nil {
p.RollbackTo(txForRollbackTo, true, false)
return utils.ErrInfo(err)
}
utils.WriteSelectiveLog("UPDATE transactions SET used=1 WHERE hex(hash) = " + string(utils.Md5(transactionBinaryDataFull)))
affect, err := p.ExecSqlGetAffect("UPDATE transactions SET used=1 WHERE hex(hash) = ?", utils.Md5(transactionBinaryDataFull))
if err != nil {
utils.WriteSelectiveLog(err)
utils.WriteSelectiveLog("RollbackTo")
p.RollbackTo(txForRollbackTo, true, false)
return utils.ErrInfo(err)
}
utils.WriteSelectiveLog("affect: " + utils.Int64ToStr(affect))
//log.Debug("transactionBinaryData", transactionBinaryData)
p.TxHash = utils.Md5(transactionBinaryData)
log.Debug("p.TxHash %s", p.TxHash)
p.TxSlice, err = p.ParseTransaction(&transactionBinaryData)
log.Debug("p.TxSlice %v", p.TxSlice)
if err != nil {
p.RollbackTo(txForRollbackTo, true, false)
return err
}
if p.BlockData.BlockId > 1 {
var userId int64
// txSlice[3] могут подсунуть пустой
if len(p.TxSlice) > 3 {
if !utils.CheckInputData(p.TxSlice[3], "int64") {
return utils.ErrInfo(fmt.Errorf("empty user_id"))
} else {
userId = utils.BytesToInt64(p.TxSlice[3])
}
} else {
return utils.ErrInfo(fmt.Errorf("empty user_id"))
}
// считаем по каждому юзеру, сколько в блоке от него транзакций
txCounter[userId]++
// чтобы 1 юзер не смог прислать дос-блок размером в 10гб, который заполнит своими же транзакциями
if txCounter[userId] > p.Variables.Int64["max_block_user_transactions"] {
p.RollbackTo(txForRollbackTo, true, false)
return utils.ErrInfo(fmt.Errorf("max_block_user_transactions"))
}
}
// время в транзакции не может быть больше, чем на MAX_TX_FORW сек времени блока
// и время в транзакции не может быть меньше времени блока -24ч.
if utils.BytesToInt64(p.TxSlice[2])-consts.MAX_TX_FORW > p.BlockData.Time || utils.BytesToInt64(p.TxSlice[2]) < p.BlockData.Time-consts.MAX_TX_BACK {
p.RollbackTo(txForRollbackTo, true, false)
return utils.ErrInfo(fmt.Errorf("incorrect transaction time"))
}
// проверим, есть ли такой тип тр-ий
_, ok := consts.TxTypes[utils.BytesToInt(p.TxSlice[1])]
if !ok {
return utils.ErrInfo(fmt.Errorf("nonexistent type"))
}
p.TxMap = map[string][]byte{}
// для статы
p.TxIds = append(p.TxIds, string(p.TxSlice[1]))
MethodName := consts.TxTypes[utils.BytesToInt(p.TxSlice[1])]
log.Debug("MethodName", MethodName+"Init")
err_ := utils.CallMethod(p, MethodName+"Init")
if _, ok := err_.(error); ok {
log.Error("error: %v", err)
return utils.ErrInfo(err_.(error))
}
log.Debug("MethodName", MethodName+"Front")
err_ = utils.CallMethod(p, MethodName+"Front")
if _, ok := err_.(error); ok {
log.Error("error: %v", err_)
p.RollbackTo(txForRollbackTo, true, false)
return utils.ErrInfo(err_.(error))
}
log.Debug("MethodName", MethodName)
err_ = utils.CallMethod(p, MethodName)
if _, ok := err_.(error); ok {
log.Error("error: %v", err)
return utils.ErrInfo(err_.(error))
}
// даем юзеру понять, что его тр-ия попала в блок
p.ExecSql("UPDATE transactions_status SET block_id = ? WHERE hex(hash) = ?", p.BlockData.BlockId, utils.Md5(transactionBinaryDataFull))
// Тут было time(). А значит если бы в цепочке блоков были блоки в которых были бы одинаковые хэши тр-ий, то ParseDataFull вернул бы error
err = p.InsertInLogTx(transactionBinaryDataFull, utils.BytesToInt64(p.TxMap["time"]))
if err != nil {
return utils.ErrInfo(err)
}
if len(p.BinaryData) == 0 {
break
}
}
}
p.UpdBlockInfo()
return nil
}
func QueueParserTx(chBreaker chan bool, chAnswer chan string) {
defer func() {
if r := recover(); r != nil {
log.Error("daemon Recovered", r)
panic(r)
}
}()
const GoroutineName = "QueueParserTx"
d := new(daemon)
d.DCDB = DbConnect(chBreaker, chAnswer, GoroutineName)
if d.DCDB == nil {
return
}
d.goRoutineName = GoroutineName
d.chAnswer = chAnswer
d.chBreaker = chBreaker
if utils.Mobile() {
d.sleepTime = 180
} else {
d.sleepTime = 1
}
if !d.CheckInstall(chBreaker, chAnswer, GoroutineName) {
return
}
d.DCDB = DbConnect(chBreaker, chAnswer, GoroutineName)
if d.DCDB == nil {
return
}
BEGIN:
for {
log.Info(GoroutineName)
MonitorDaemonCh <- []string{GoroutineName, utils.Int64ToStr(utils.Time())}
// проверим, не нужно ли нам выйти из цикла
if CheckDaemonsRestart(chBreaker, chAnswer, GoroutineName) {
break BEGIN
}
err, restart := d.dbLock()
if restart {
break BEGIN
}
if err != nil {
if d.dPrintSleep(err, d.sleepTime) {
break BEGIN
}
continue BEGIN
}
blockId, err := d.GetBlockId()
if err != nil {
if d.unlockPrintSleep(utils.ErrInfo(err), d.sleepTime) {
break BEGIN
}
continue BEGIN
}
if blockId == 0 {
if d.unlockPrintSleep(utils.ErrInfo("blockId == 0"), d.sleepTime) {
break BEGIN
}
continue BEGIN
}
// чистим зацикленные
utils.WriteSelectiveLog("DELETE FROM transactions WHERE verified = 0 AND used = 0 AND counter > 10")
affect, err := d.ExecSqlGetAffect("DELETE FROM transactions WHERE verified = 0 AND used = 0 AND counter > 10")
if err != nil {
utils.WriteSelectiveLog(err)
if d.unlockPrintSleep(utils.ErrInfo(err), d.sleepTime) {
break BEGIN
}
continue BEGIN
}
utils.WriteSelectiveLog("affect: " + utils.Int64ToStr(affect))
p := new(dcparser.Parser)
p.DCDB = d.DCDB
err = p.AllTxParser()
if err != nil {
if d.unlockPrintSleep(utils.ErrInfo(err), d.sleepTime) {
break BEGIN
}
continue BEGIN
}
d.dbUnlock()
if d.dSleep(d.sleepTime) {
break BEGIN
}
}
log.Debug("break BEGIN %v", GoroutineName)
}