ServerStorage.vue 21 KB

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