tree.go 7.4 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264
  1. // SiYuan - Build Your Eternal Digital Garden
  2. // Copyright (c) 2020-present, b3log.org
  3. //
  4. // This program is free software: you can redistribute it and/or modify
  5. // it under the terms of the GNU Affero General Public License as published by
  6. // the Free Software Foundation, either version 3 of the License, or
  7. // (at your option) any later version.
  8. //
  9. // This program is distributed in the hope that it will be useful,
  10. // but WITHOUT ANY WARRANTY; without even the implied warranty of
  11. // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  12. // GNU Affero General Public License for more details.
  13. //
  14. // You should have received a copy of the GNU Affero General Public License
  15. // along with this program. If not, see <https://www.gnu.org/licenses/>.
  16. package filesys
  17. import (
  18. "bytes"
  19. "encoding/json"
  20. "errors"
  21. "fmt"
  22. "os"
  23. "path/filepath"
  24. "strings"
  25. "time"
  26. "github.com/88250/lute"
  27. "github.com/88250/lute/parse"
  28. "github.com/88250/lute/render"
  29. "github.com/siyuan-note/filelock"
  30. "github.com/siyuan-note/logging"
  31. "github.com/siyuan-note/siyuan/kernel/cache"
  32. "github.com/siyuan-note/siyuan/kernel/treenode"
  33. "github.com/siyuan-note/siyuan/kernel/util"
  34. )
  35. func LoadTree(boxID, p string, luteEngine *lute.Lute) (ret *parse.Tree, err error) {
  36. filePath := filepath.Join(util.DataDir, boxID, p)
  37. data, err := filelock.ReadFile(filePath)
  38. if nil != err {
  39. return
  40. }
  41. ret = parseJSON2Tree(boxID, p, data, luteEngine)
  42. if nil == ret {
  43. ret = recoverParseJSON2Tree(boxID, p, filePath, luteEngine)
  44. if nil == ret {
  45. return nil, errors.New("parse tree failed")
  46. }
  47. }
  48. ret.Path = p
  49. ret.Root.Path = p
  50. parts := strings.Split(p, "/")
  51. parts = parts[1 : len(parts)-1] // 去掉开头的斜杆和结尾的自己
  52. if 1 > len(parts) {
  53. ret.HPath = "/" + ret.Root.IALAttr("title")
  54. ret.Hash = treenode.NodeHash(ret.Root, ret, luteEngine)
  55. return
  56. }
  57. // 构造 HPath
  58. hPathBuilder := bytes.Buffer{}
  59. hPathBuilder.WriteString("/")
  60. for i, _ := range parts {
  61. var parentAbsPath string
  62. if 0 < i {
  63. parentAbsPath = strings.Join(parts[:i+1], "/")
  64. } else {
  65. parentAbsPath = parts[0]
  66. }
  67. parentAbsPath += ".sy"
  68. parentPath := parentAbsPath
  69. parentAbsPath = filepath.Join(util.DataDir, boxID, parentAbsPath)
  70. parentData, readErr := filelock.ReadFile(parentAbsPath)
  71. if nil != readErr {
  72. if os.IsNotExist(readErr) {
  73. parentTree := treenode.NewTree(boxID, parentPath, hPathBuilder.String()+"Untitled", "Untitled")
  74. if writeErr := WriteTree(parentTree); nil != writeErr {
  75. logging.LogErrorf("rebuild parent tree [%s] failed: %s", parentAbsPath, writeErr)
  76. } else {
  77. logging.LogInfof("rebuilt parent tree [%s]", parentAbsPath)
  78. }
  79. } else {
  80. logging.LogWarnf("read parent tree data [%s] failed: %s", parentAbsPath, readErr)
  81. }
  82. hPathBuilder.WriteString("Untitled/")
  83. continue
  84. }
  85. parentTree, parseErr := parse.ParseJSONWithoutFix(parentData, luteEngine.ParseOptions)
  86. if nil != parseErr {
  87. logging.LogWarnf("parse parent tree [%s] failed: %s", parentAbsPath, parseErr)
  88. hPathBuilder.WriteString("Untitled/")
  89. continue
  90. }
  91. hPathBuilder.WriteString(parentTree.Root.IALAttr("title"))
  92. hPathBuilder.WriteString("/")
  93. }
  94. hPathBuilder.WriteString(ret.Root.IALAttr("title"))
  95. ret.HPath = hPathBuilder.String()
  96. ret.Hash = treenode.NodeHash(ret.Root, ret, luteEngine)
  97. return
  98. }
  99. func WriteTreeWithoutChangeTime(tree *parse.Tree) (err error) {
  100. data, filePath, err := prepareWriteTree(tree)
  101. if nil != err {
  102. return
  103. }
  104. if err = filelock.WriteFileWithoutChangeTime(filePath, data); nil != err {
  105. if errors.Is(err, filelock.ErrUnableAccessFile) {
  106. return
  107. }
  108. msg := fmt.Sprintf("write data [%s] failed: %s", filePath, err)
  109. logging.LogErrorf(msg)
  110. return errors.New(msg)
  111. }
  112. afterWriteTree(tree)
  113. return
  114. }
  115. func WriteTree(tree *parse.Tree) (err error) {
  116. data, filePath, err := prepareWriteTree(tree)
  117. if nil != err {
  118. return
  119. }
  120. if err = filelock.WriteFile(filePath, data); nil != err {
  121. if errors.Is(err, filelock.ErrUnableAccessFile) {
  122. return
  123. }
  124. msg := fmt.Sprintf("write data [%s] failed: %s", filePath, err)
  125. logging.LogErrorf(msg)
  126. return errors.New(msg)
  127. }
  128. afterWriteTree(tree)
  129. return
  130. }
  131. func prepareWriteTree(tree *parse.Tree) (data []byte, filePath string, err error) {
  132. luteEngine := util.NewLute() // 不关注用户的自定义解析渲染选项
  133. if nil == tree.Root.FirstChild {
  134. newP := parse.NewParagraph()
  135. tree.Root.AppendChild(newP)
  136. tree.Root.SetIALAttr("updated", util.TimeFromID(newP.ID))
  137. treenode.ReindexBlockTree(tree)
  138. }
  139. filePath = filepath.Join(util.DataDir, tree.Box, tree.Path)
  140. if oldSpec := tree.Root.Spec; "" == oldSpec {
  141. luteEngine.NestedInlines2FlattedSpans(tree)
  142. tree.Root.Spec = "1"
  143. logging.LogInfof("migrated tree [%s] from spec [%s] to [%s]", filePath, oldSpec, tree.Root.Spec)
  144. }
  145. renderer := render.NewJSONRenderer(tree, luteEngine.RenderOptions)
  146. data = renderer.Render()
  147. // .sy 文档数据使用格式化好的 JSON 而非单行 JSON
  148. buf := bytes.Buffer{}
  149. buf.Grow(4096)
  150. if err = json.Indent(&buf, data, "", "\t"); nil != err {
  151. return
  152. }
  153. data = buf.Bytes()
  154. if err = os.MkdirAll(filepath.Dir(filePath), 0755); nil != err {
  155. return
  156. }
  157. return
  158. }
  159. func afterWriteTree(tree *parse.Tree) {
  160. docIAL := parse.IAL2MapUnEsc(tree.Root.KramdownIAL)
  161. cache.PutDocIAL(tree.Path, docIAL)
  162. }
  163. func recoverParseJSON2Tree(boxID, p, filePath string, luteEngine *lute.Lute) (ret *parse.Tree) {
  164. // 尝试从临时文件恢复
  165. tmp := util.LatestTmpFile(filePath)
  166. if "" == tmp {
  167. logging.LogWarnf("recover tree [%s] not found tmp", filePath)
  168. return
  169. }
  170. stat, err := os.Stat(filePath)
  171. if nil != err {
  172. logging.LogErrorf("stat tmp [%s] failed: %s", tmp, err)
  173. return
  174. }
  175. if stat.ModTime().Before(time.Now().Add(-time.Hour * 24)) {
  176. logging.LogWarnf("tmp [%s] is too old, remove it", tmp)
  177. os.RemoveAll(tmp)
  178. return
  179. }
  180. data, err := filelock.ReadFile(tmp)
  181. if nil != err {
  182. logging.LogErrorf("recover tree read from tmp [%s] failed: %s", tmp, err)
  183. return
  184. }
  185. if err = filelock.WriteFile(filePath, data); nil != err {
  186. logging.LogErrorf("recover tree write [%s] from tmp [%s] failed: %s", filePath, tmp, err)
  187. return
  188. }
  189. ret = parseJSON2Tree(boxID, p, data, luteEngine)
  190. if nil == ret {
  191. logging.LogErrorf("recover tree from tmp [%s] parse failed, remove it", tmp)
  192. os.RemoveAll(tmp)
  193. return
  194. }
  195. logging.LogInfof("recovered tree [%s] from [%s]", filePath, tmp)
  196. os.RemoveAll(tmp)
  197. return
  198. }
  199. func parseJSON2Tree(boxID, p string, jsonData []byte, luteEngine *lute.Lute) (ret *parse.Tree) {
  200. var err error
  201. var needFix bool
  202. ret, needFix, err = parse.ParseJSON(jsonData, luteEngine.ParseOptions)
  203. if nil != err {
  204. logging.LogErrorf("parse json [%s] to tree failed: %s", boxID+p, err)
  205. return
  206. }
  207. ret.Box = boxID
  208. ret.Path = p
  209. filePath := filepath.Join(util.DataDir, ret.Box, ret.Path)
  210. if oldSpec := ret.Root.Spec; "" == oldSpec {
  211. luteEngine.NestedInlines2FlattedSpans(ret)
  212. ret.Root.Spec = "1"
  213. needFix = true
  214. logging.LogInfof("migrated tree [%s] from spec [%s] to [%s]", filePath, oldSpec, ret.Root.Spec)
  215. }
  216. if needFix {
  217. renderer := render.NewJSONRenderer(ret, luteEngine.RenderOptions)
  218. output := renderer.Render()
  219. buf := bytes.Buffer{}
  220. buf.Grow(4096)
  221. if err = json.Indent(&buf, output, "", "\t"); nil != err {
  222. return
  223. }
  224. output = buf.Bytes()
  225. if err = os.MkdirAll(filepath.Dir(filePath), 0755); nil != err {
  226. return
  227. }
  228. if err = filelock.WriteFile(filePath, output); nil != err {
  229. msg := fmt.Sprintf("write data [%s] failed: %s", filePath, err)
  230. logging.LogErrorf(msg)
  231. }
  232. }
  233. return
  234. }