ServerStorage.vue 24 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688
  1. <template>
  2. <div></div>
  3. </template>
  4. <script>
  5. //-----------------------------------------------------------------------------
  6. import Vue from 'vue';
  7. import Component from 'vue-class-component';
  8. import _ from 'lodash';
  9. import bookManager from '../share/bookManager';
  10. import readerApi from '../../../api/reader';
  11. import * as utils from '../../../share/utils';
  12. import * as cryptoUtils from '../../../share/cryptoUtils';
  13. const maxSetTries = 5;
  14. export default @Component({
  15. watch: {
  16. serverSyncEnabled: function() {
  17. this.serverSyncEnabledChanged();
  18. },
  19. serverStorageKey: function() {
  20. this.serverStorageKeyChanged(true);
  21. },
  22. settings: function() {
  23. this.debouncedSaveSettings();
  24. },
  25. profiles: function() {
  26. this.saveProfiles();
  27. },
  28. currentProfile: function() {
  29. this.currentProfileChanged(true);
  30. },
  31. },
  32. })
  33. class ServerStorage extends Vue {
  34. created() {
  35. this.inited = false;
  36. this.keyInited = false;
  37. this.commit = this.$store.commit;
  38. this.prevServerStorageKey = null;
  39. this.$root.$on('generateNewServerStorageKey', () => {this.generateNewServerStorageKey()});
  40. this.debouncedSaveSettings = _.debounce(() => {
  41. this.saveSettings();
  42. }, 500);
  43. this.oldProfiles = {};
  44. this.oldSettings = {};
  45. this.oldRecent = {};
  46. this.oldRecentLast = {};
  47. this.oldRecentLastDiff = {};
  48. }
  49. async init() {
  50. try {
  51. if (!this.serverStorageKey) {
  52. //генерируем новый ключ
  53. await this.generateNewServerStorageKey();
  54. } else {
  55. await this.serverStorageKeyChanged();
  56. }
  57. this.oldRecent = _.cloneDeep(bookManager.recent);
  58. this.oldRecentLast = _.cloneDeep(bookManager.recentLast) || {};
  59. } finally {
  60. this.inited = true;
  61. }
  62. }
  63. async generateNewServerStorageKey() {
  64. const key = utils.toBase58(utils.randomArray(32));
  65. this.commit('reader/setServerStorageKey', key);
  66. await this.serverStorageKeyChanged(true);
  67. }
  68. async serverSyncEnabledChanged() {
  69. if (this.serverSyncEnabled) {
  70. this.prevServerStorageKey = null;
  71. if (!this.serverStorageKey) {
  72. //генерируем новый ключ
  73. await this.generateNewServerStorageKey();
  74. } else {
  75. await this.serverStorageKeyChanged(true);
  76. }
  77. }
  78. }
  79. async serverStorageKeyChanged(force) {
  80. if (this.prevServerStorageKey != this.serverStorageKey) {
  81. this.prevServerStorageKey = this.serverStorageKey;
  82. this.hashedStorageKey = utils.toBase58(cryptoUtils.sha256(this.serverStorageKey));
  83. this.keyInited = true;
  84. await this.loadProfiles(force);
  85. this.checkCurrentProfile();
  86. await this.currentProfileChanged(force);
  87. await this.loadRecent(force);
  88. if (force)
  89. await this.saveRecent();
  90. }
  91. }
  92. async currentProfileChanged(force) {
  93. if (!this.currentProfile)
  94. return;
  95. await this.loadSettings(force);
  96. }
  97. get serverSyncEnabled() {
  98. return this.$store.state.reader.serverSyncEnabled;
  99. }
  100. get settings() {
  101. return this.$store.state.reader.settings;
  102. }
  103. get settingsRev() {
  104. return this.$store.state.reader.settingsRev;
  105. }
  106. get serverStorageKey() {
  107. return this.$store.state.reader.serverStorageKey;
  108. }
  109. get profiles() {
  110. return this.$store.state.reader.profiles;
  111. }
  112. get profilesRev() {
  113. return this.$store.state.reader.profilesRev;
  114. }
  115. get currentProfile() {
  116. return this.$store.state.reader.currentProfile;
  117. }
  118. get showServerStorageMessages() {
  119. return this.settings.showServerStorageMessages;
  120. }
  121. checkCurrentProfile() {
  122. if (!this.profiles[this.currentProfile]) {
  123. this.commit('reader/setCurrentProfile', '');
  124. }
  125. }
  126. notifySuccess() {
  127. this.success('Данные синхронизированы с сервером');
  128. }
  129. success(message) {
  130. if (this.showServerStorageMessages)
  131. this.$notify.success({message});
  132. }
  133. warning(message) {
  134. if (this.showServerStorageMessages)
  135. this.$notify.warning({message});
  136. }
  137. error(message) {
  138. if (this.showServerStorageMessages)
  139. this.$notify.error({message});
  140. }
  141. async loadSettings(force) {
  142. if (!this.keyInited || !this.serverSyncEnabled || !this.currentProfile)
  143. return;
  144. const setsId = `settings-${this.currentProfile}`;
  145. const oldRev = this.settingsRev[setsId] || 0;
  146. //проверим ревизию на сервере
  147. if (!force) {
  148. try {
  149. const revs = await this.storageCheck({[setsId]: {}});
  150. if (revs.state == 'success' && revs.items[setsId].rev == oldRev) {
  151. return;
  152. }
  153. } catch(e) {
  154. this.error(`Ошибка соединения с сервером: ${e.message}`);
  155. return;
  156. }
  157. }
  158. let sets = null;
  159. try {
  160. sets = await this.storageGet({[setsId]: {}});
  161. } catch(e) {
  162. this.error(`Ошибка соединения с сервером: ${e.message}`);
  163. return;
  164. }
  165. if (sets.state == 'success') {
  166. sets = sets.items[setsId];
  167. if (sets.rev == 0)
  168. sets.data = {};
  169. this.oldSettings = _.cloneDeep(sets.data);
  170. this.commit('reader/setSettings', sets.data);
  171. this.commit('reader/setSettingsRev', {[setsId]: sets.rev});
  172. this.notifySuccess();
  173. } else {
  174. this.warning(`Неверный ответ сервера: ${sets.state}`);
  175. }
  176. }
  177. async saveSettings() {
  178. if (!this.keyInited || !this.serverSyncEnabled || !this.currentProfile || this.savingSettings)
  179. return;
  180. const diff = utils.getObjDiff(this.oldSettings, this.settings);
  181. if (utils.isEmptyObjDiff(diff))
  182. return;
  183. this.savingSettings = true;
  184. try {
  185. const setsId = `settings-${this.currentProfile}`;
  186. let result = {state: ''};
  187. let tries = 0;
  188. while (result.state != 'success' && tries < maxSetTries) {
  189. const oldRev = this.settingsRev[setsId] || 0;
  190. try {
  191. result = await this.storageSet({[setsId]: {rev: oldRev + 1, data: this.settings}});
  192. } catch(e) {
  193. this.savingSettings = false;
  194. this.error(`Ошибка соединения с сервером (${e.message}). Данные не сохранены и могут быть перезаписаны.`);
  195. return;
  196. }
  197. if (result.state == 'reject') {
  198. await this.loadSettings(true);
  199. const newSettings = utils.applyObjDiff(this.settings, diff);
  200. this.commit('reader/setSettings', newSettings);
  201. }
  202. tries++;
  203. }
  204. if (tries >= maxSetTries) {
  205. //отменять изменения не будем, просто предупредим
  206. //this.commit('reader/setSettings', this.oldSettings);
  207. console.error(result);
  208. this.error('Не удалось отправить настройки на сервер. Данные не сохранены и могут быть перезаписаны.');
  209. } else {
  210. this.oldSettings = _.cloneDeep(this.settings);
  211. this.commit('reader/setSettingsRev', {[setsId]: this.settingsRev[setsId] + 1});
  212. }
  213. } finally {
  214. this.savingSettings = false;
  215. }
  216. }
  217. async loadProfiles(force) {
  218. if (!this.keyInited || !this.serverSyncEnabled)
  219. return;
  220. const oldRev = this.profilesRev;
  221. //проверим ревизию на сервере
  222. if (!force) {
  223. try {
  224. const revs = await this.storageCheck({profiles: {}});
  225. if (revs.state == 'success' && revs.items.profiles.rev == oldRev) {
  226. return;
  227. }
  228. } catch(e) {
  229. this.error(`Ошибка соединения с сервером: ${e.message}`);
  230. return;
  231. }
  232. }
  233. let prof = null;
  234. try {
  235. prof = await this.storageGet({profiles: {}});
  236. } catch(e) {
  237. this.error(`Ошибка соединения с сервером: ${e.message}`);
  238. return;
  239. }
  240. if (prof.state == 'success') {
  241. prof = prof.items.profiles;
  242. if (prof.rev == 0)
  243. prof.data = {};
  244. this.oldProfiles = _.cloneDeep(prof.data);
  245. this.commit('reader/setProfiles', prof.data);
  246. this.commit('reader/setProfilesRev', prof.rev);
  247. this.notifySuccess();
  248. } else {
  249. this.warning(`Неверный ответ сервера: ${prof.state}`);
  250. }
  251. }
  252. async saveProfiles() {
  253. if (!this.keyInited || !this.serverSyncEnabled || this.savingProfiles)
  254. return;
  255. const diff = utils.getObjDiff(this.oldProfiles, this.profiles);
  256. if (utils.isEmptyObjDiff(diff))
  257. return;
  258. //обнуляются профили во время разработки, подстраховка
  259. if (!this.$store.state.reader.allowProfilesSave) {
  260. console.error('Сохранение профилей не санкционировано');
  261. return;
  262. }
  263. this.savingProfiles = true;
  264. try {
  265. let result = {state: ''};
  266. let tries = 0;
  267. while (result.state != 'success' && tries < maxSetTries) {
  268. try {
  269. result = await this.storageSet({profiles: {rev: this.profilesRev + 1, data: this.profiles}});
  270. } catch(e) {
  271. this.savingProfiles = false;
  272. this.commit('reader/setProfiles', this.oldProfiles);
  273. this.checkCurrentProfile();
  274. this.error(`Ошибка соединения с сервером: (${e.message}). Изменения отменены.`);
  275. return;
  276. }
  277. if (result.state == 'reject') {
  278. await this.loadProfiles(true);
  279. const newProfiles = utils.applyObjDiff(this.profiles, diff);
  280. this.commit('reader/setProfiles', newProfiles);
  281. }
  282. tries++;
  283. }
  284. if (tries >= maxSetTries) {
  285. this.commit('reader/setProfiles', this.oldProfiles);
  286. this.checkCurrentProfile();
  287. console.error(result);
  288. this.error('Не удалось отправить данные на сервер. Изменения отменены.');
  289. } else {
  290. this.oldProfiles = _.cloneDeep(this.profiles);
  291. this.commit('reader/setProfilesRev', this.profilesRev + 1);
  292. }
  293. } finally {
  294. this.savingProfiles = false;
  295. }
  296. }
  297. async loadRecent(force) {
  298. if (!this.keyInited || !this.serverSyncEnabled)
  299. return;
  300. const oldRev = bookManager.recentRev;
  301. const oldLastRev = bookManager.recentLastRev;
  302. const oldLastDiffRev = bookManager.recentLastDiffRev;
  303. //проверим ревизию на сервере
  304. let revs = null;
  305. if (!force) {
  306. try {
  307. revs = await this.storageCheck({recent: {}, recentLast: {}, recentLastDiff: {}});
  308. if (revs.state == 'success' && revs.items.recent.rev == oldRev &&
  309. revs.items.recentLast.rev == oldLastRev &&
  310. revs.items.recentLastDiff.rev == oldLastDiffRev) {
  311. return;
  312. }
  313. } catch(e) {
  314. this.error(`Ошибка соединения с сервером: ${e.message}`);
  315. return;
  316. }
  317. }
  318. if (force || revs.items.recent.rev != oldRev) {
  319. let recent = null;
  320. try {
  321. recent = await this.storageGet({recent: {}});
  322. } catch(e) {
  323. this.error(`Ошибка соединения с сервером: ${e.message}`);
  324. return;
  325. }
  326. if (recent.state == 'success') {
  327. recent = recent.items.recent;
  328. if (recent.rev == 0)
  329. recent.data = {};
  330. this.oldRecent = _.cloneDeep(recent.data);
  331. await bookManager.setRecent(recent.data);
  332. await bookManager.setRecentRev(recent.rev);
  333. } else {
  334. this.warning(`Неверный ответ сервера: ${recent.state}`);
  335. }
  336. }
  337. if (force || revs.items.recentLast.rev != oldLastRev || revs.items.recentLastDiff.rev != oldLastDiffRev) {
  338. let recentLast = null;
  339. try {
  340. recentLast = await this.storageGet({recentLast: {}, recentLastDiff: {}});
  341. } catch(e) {
  342. this.error(`Ошибка соединения с сервером: ${e.message}`);
  343. return;
  344. }
  345. if (recentLast.state == 'success') {
  346. const recentLastDiff = recentLast.items.recentLastDiff;
  347. recentLast = recentLast.items.recentLast;
  348. if (recentLast.rev == 0)
  349. recentLast.data = {};
  350. if (recentLastDiff.rev == 0)
  351. recentLastDiff.data = {};
  352. recentLast.data = utils.applyObjDiff(recentLast.data, recentLastDiff.data);
  353. this.oldRecentLast = _.cloneDeep(recentLast.data);
  354. await bookManager.setRecentLast(recentLast.data);
  355. await bookManager.setRecentLastRev(recentLast.rev);
  356. await bookManager.setRecentLastDiffRev(recentLastDiff.rev);
  357. } else {
  358. this.warning(`Неверный ответ сервера: ${recentLast.state}`);
  359. }
  360. }
  361. this.notifySuccess();
  362. }
  363. async saveRecent() {
  364. if (!this.keyInited || !this.serverSyncEnabled || this.savingRecent)
  365. return;
  366. const bm = bookManager;
  367. const diff = utils.getObjDiff(this.oldRecent, bm.recent);
  368. if (utils.isEmptyObjDiff(diff))
  369. return;
  370. this.savingRecent = true;
  371. try {
  372. let result = {state: ''};
  373. let tries = 0;
  374. while (result.state != 'success' && tries < maxSetTries) {
  375. try {
  376. result = await this.storageSet({recent: {rev: bm.recentRev + 1, data: bm.recent}});
  377. } catch(e) {
  378. this.savingRecent = false;
  379. this.error(`Ошибка соединения с сервером: (${e.message}). Изменения не сохранены.`);
  380. return;
  381. }
  382. if (result.state == 'reject') {
  383. await this.loadRecent(true);
  384. //похоже это лишнее
  385. /*const newRecent = utils.applyObjDiff(bm.recent, diff);
  386. await bm.setRecent(newRecent);*/
  387. }
  388. tries++;
  389. }
  390. if (tries >= maxSetTries) {
  391. console.error(result);
  392. this.error('Не удалось отправить данные на сервер. Данные не сохранены и могут быть перезаписаны.');
  393. } else {
  394. this.oldRecent = _.cloneDeep(bm.recent);
  395. await bm.setRecentRev(bm.recentRev + 1);
  396. await this.saveRecentLast(true);
  397. }
  398. } finally {
  399. this.savingRecent = false;
  400. }
  401. }
  402. async saveRecentLast(force = false) {
  403. if (!this.keyInited || !this.serverSyncEnabled || this.savingRecentLast)
  404. return;
  405. const bm = bookManager;
  406. let recentLast = bm.recentLast;
  407. recentLast = (recentLast ? recentLast : {});
  408. let lastRev = bm.recentLastRev;
  409. const diff = utils.getObjDiff(this.oldRecentLast, recentLast);
  410. if (utils.isEmptyObjDiff(diff))
  411. return;
  412. if (JSON.stringify(recentLast) > JSON.stringify(diff)) {
  413. await this.saveRecentLastDiff(diff, force);
  414. return;
  415. }
  416. this.savingRecentLast = true;
  417. try {
  418. let result = {state: ''};
  419. let tries = 0;
  420. while (result.state != 'success' && tries < maxSetTries) {
  421. if (force) {
  422. try {
  423. const revs = await this.storageCheck({recentLast: {}});
  424. if (revs.items.recentLast.rev)
  425. lastRev = revs.items.recentLast.rev;
  426. } catch(e) {
  427. this.error(`Ошибка соединения с сервером: ${e.message}`);
  428. return;
  429. }
  430. }
  431. try {
  432. result = await this.storageSet({recentLast: {rev: lastRev + 1, data: recentLast}}, force);
  433. } catch(e) {
  434. this.savingRecentLast = false;
  435. this.error(`Ошибка соединения с сервером: (${e.message}). Изменения не сохранены.`);
  436. return;
  437. }
  438. if (result.state == 'reject') {
  439. await this.loadRecent(false);
  440. this.savingRecentLast = false;//!!!
  441. return;//!!!
  442. }
  443. tries++;
  444. }
  445. if (tries >= maxSetTries) {
  446. console.error(result);
  447. this.error('Не удалось отправить данные на сервер. Данные не сохранены и могут быть перезаписаны.');
  448. } else {
  449. this.oldRecentLast = _.cloneDeep(recentLast);
  450. await bm.setRecentLastRev(lastRev + 1);
  451. }
  452. } finally {
  453. this.savingRecentLast = false;
  454. }
  455. }
  456. async saveRecentLastDiff(diff, force = false) {
  457. if (!this.keyInited || !this.serverSyncEnabled || this.savingRecentLastDiff)
  458. return;
  459. const bm = bookManager;
  460. let lastRev = bm.recentLastDiffRev;
  461. const d = utils.getObjDiff(this.oldRecentLastDiff, diff);
  462. if (utils.isEmptyObjDiff(d))
  463. return;
  464. this.savingRecentLastDiff = true;
  465. try {
  466. let result = {state: ''};
  467. let tries = 0;
  468. while (result.state != 'success' && tries < maxSetTries) {
  469. if (force) {
  470. try {
  471. const revs = await this.storageCheck({recentLastDiff: {}});
  472. if (revs.items.recentLastDiff.rev)
  473. lastRev = revs.items.recentLastDiff.rev;
  474. } catch(e) {
  475. this.error(`Ошибка соединения с сервером: ${e.message}`);
  476. return;
  477. }
  478. }
  479. try {
  480. result = await this.storageSet({recentLastDiff: {rev: lastRev + 1, data: diff}}, force);
  481. } catch(e) {
  482. this.savingRecentLastDiff = false;
  483. this.error(`Ошибка соединения с сервером: (${e.message}). Изменения не сохранены.`);
  484. return;
  485. }
  486. if (result.state == 'reject') {
  487. await this.loadRecent(false);
  488. this.savingRecentLastDiff = false;
  489. return;
  490. }
  491. tries++;
  492. }
  493. if (tries >= maxSetTries) {
  494. console.error(result);
  495. this.error('Не удалось отправить данные на сервер. Данные не сохранены и могут быть перезаписаны.');
  496. } else {
  497. this.oldRecentLastDiff = _.cloneDeep(diff);
  498. await bm.setRecentLastDiffRev(lastRev + 1);
  499. }
  500. } finally {
  501. this.savingRecentLastDiff = false;
  502. }
  503. }
  504. async storageCheck(items) {
  505. return await this.storageApi('check', items);
  506. }
  507. async storageGet(items) {
  508. return await this.storageApi('get', items);
  509. }
  510. async storageSet(items, force) {
  511. return await this.storageApi('set', items, force);
  512. }
  513. async storageApi(action, items, force) {
  514. const request = {action, items};
  515. if (force)
  516. request.force = true;
  517. const encodedRequest = await this.encodeStorageItems(request);
  518. return await this.decodeStorageItems(await readerApi.storage(encodedRequest));
  519. }
  520. async encodeStorageItems(request) {
  521. if (!this.hashedStorageKey)
  522. throw new Error('hashedStorageKey is empty');
  523. if (!_.isObject(request.items))
  524. throw new Error('items is not an object');
  525. let result = Object.assign({}, request);
  526. let items = {};
  527. for (const id of Object.keys(request.items)) {
  528. const item = request.items[id];
  529. if (request.action == 'set' && !_.isObject(item.data))
  530. throw new Error('encodeStorageItems: data is not an object');
  531. let encoded = Object.assign({}, item);
  532. if (item.data) {
  533. const comp = utils.pako.deflate(JSON.stringify(item.data), {level: 1});
  534. let encrypted = null;
  535. try {
  536. encrypted = cryptoUtils.aesEncrypt(comp, this.serverStorageKey);
  537. } catch (e) {
  538. throw new Error('encrypt failed');
  539. }
  540. encoded.data = '1' + utils.toBase64(encrypted);
  541. }
  542. items[`${this.hashedStorageKey}.${utils.toBase58(id)}`] = encoded;
  543. }
  544. result.items = items;
  545. return result;
  546. }
  547. async decodeStorageItems(response) {
  548. if (!this.hashedStorageKey)
  549. throw new Error('hashedStorageKey is empty');
  550. let result = Object.assign({}, response);
  551. let items = {};
  552. if (response.items) {
  553. if (!_.isObject(response.items))
  554. throw new Error('items is not an object');
  555. for (const id of Object.keys(response.items)) {
  556. const item = response.items[id];
  557. let decoded = Object.assign({}, item);
  558. if (item.data) {
  559. if (!_.isString(item.data) || !item.data.length)
  560. throw new Error('decodeStorageItems: data is not a string');
  561. if (item.data[0] !== '1')
  562. throw new Error('decodeStorageItems: unknown data format');
  563. const a = utils.fromBase64(item.data.substr(1));
  564. let decrypted = null;
  565. try {
  566. decrypted = cryptoUtils.aesDecrypt(a, this.serverStorageKey);
  567. } catch (e) {
  568. throw new Error('decrypt failed');
  569. }
  570. decoded.data = JSON.parse(utils.pako.inflate(decrypted, {to: 'string'}));
  571. }
  572. const ids = id.split('.');
  573. if (!(ids.length == 2) || !(ids[0] == this.hashedStorageKey))
  574. throw new Error(`decodeStorageItems: bad id - ${id}`);
  575. items[utils.fromBase58(ids[1])] = decoded;
  576. }
  577. }
  578. result.items = items;
  579. return result;
  580. }
  581. }
  582. //-----------------------------------------------------------------------------
  583. </script>