Git commit 510f3761182891c75d3872c951eb4360468f3772 by Valentin Rusu.
Committed on 11/08/2015 at 14:23.
Pushed by vrusu into branch 'master'.

Continuing ksecrets_backend renaming to ksecrets_store

M  +9    -9    src/runtime/ksecrets_store/CMakeLists.txt
R  +29   -29   src/runtime/ksecrets_store/ksecrets_store.cpp [from: src/run=
time/ksecrets_store/ksecrets_backend.cpp - 062% similarity]
R  +8    -8    src/runtime/ksecrets_store/ksecrets_store.h [from: src/runti=
me/ksecrets_store/ksecrets_backend.h - 096% similarity]
R  +14   -14   src/runtime/ksecrets_store/ksecrets_store_p.h [from: src/run=
time/ksecrets_store/ksecrets_backend_p.h - 070% similarity]

http://commits.kde.org/ksecrets/510f3761182891c75d3872c951eb4360468f3772

diff --git a/src/runtime/ksecrets_store/CMakeLists.txt b/src/runtime/ksecre=
ts_store/CMakeLists.txt
index 92a3244..dcee020 100644
--- a/src/runtime/ksecrets_store/CMakeLists.txt
+++ b/src/runtime/ksecrets_store/CMakeLists.txt
@@ -5,18 +5,18 @@ find_package(LibGcrypt 1.6.0 REQUIRED)
 cmake_minimum_required(VERSION 3.2.2)
 =

 ecm_setup_version(${KF5_VERSION} VARIABLE_PREFIX KSECRETS_BACKEND
-                  VERSION_HEADER "${CMAKE_CURRENT_BINARY_DIR}/ksecrets_bac=
kend_version.h"
-                  PACKAGE_VERSION_FILE "${CMAKE_CURRENT_BINARY_DIR}/KF5Sec=
retsBackendConfigVersion.cmake")
+                  VERSION_HEADER "${CMAKE_CURRENT_BINARY_DIR}/ksecrets_sto=
re_version.h"
+                  PACKAGE_VERSION_FILE "${CMAKE_CURRENT_BINARY_DIR}/KF5Sec=
retsStoreConfigVersion.cmake")
 =

-set(ksecrets_backend_SRC
+set(ksecrets_store_SRC
    ksecrets_crypt.c
-   ksecrets_backend.cpp)
+   ksecrets_store.cpp)
 =

-add_library(ksecrets_backend SHARED ${ksecrets_backend_SRC})
-generate_export_header(ksecrets_backend BASE_NAME ksecrets_backend)
-target_link_libraries(ksecrets_backend
+add_library(ksecrets_store SHARED ${ksecrets_store_SRC})
+generate_export_header(ksecrets_store BASE_NAME ksecrets_store)
+target_link_libraries(ksecrets_store
    pthread
    ${LIBGCRYPT_LIBRARIES})
-target_compile_features(ksecrets_backend PRIVATE cxx_range_for)
-set_target_properties(ksecrets_backend PROPERTIES PREFIX "")
+target_compile_features(ksecrets_store PRIVATE cxx_range_for)
+set_target_properties(ksecrets_store PROPERTIES PREFIX "")
 =

diff --git a/src/runtime/ksecrets_store/ksecrets_backend.cpp b/src/runtime/=
ksecrets_store/ksecrets_store.cpp
similarity index 62%
rename from src/runtime/ksecrets_store/ksecrets_backend.cpp
rename to src/runtime/ksecrets_store/ksecrets_store.cpp
index 3395f64..775f896 100644
--- a/src/runtime/ksecrets_store/ksecrets_backend.cpp
+++ b/src/runtime/ksecrets_store/ksecrets_store.cpp
@@ -19,8 +19,8 @@
     Boston, MA 02110-1301, USA.
 */
 =

-#include "ksecrets_backend.h"
-#include "ksecrets_backend_p.h"
+#include "ksecrets_store.h"
+#include "ksecrets_store_p.h"
 =

 #include <future>
 #include <thread>
@@ -30,20 +30,20 @@
 #define GCRPYT_NO_DEPRECATED
 #include <gcrypt.h>
 =

-KSecretsBackendPrivate::KSecretsBackendPrivate(KSecretsBackend* b)
+KSecretsStorePrivate::KSecretsStorePrivate(KSecretsStore* b)
     : b_(b)
 {
-    openStatus_.status_ =3D KSecretsBackend::OpenStatus::NotYetOpened;
+    openStatus_.status_ =3D KSecretsStore::OpenStatus::NotYetOpened;
 }
 =

-KSecretsBackend::KSecretsBackend()
-    : d(new KSecretsBackendPrivate(this))
+KSecretsStore::KSecretsStore()
+    : d(new KSecretsStorePrivate(this))
 {
 }
 =

-KSecretsBackend::~KSecretsBackend() =3D default;
+KSecretsStore::~KSecretsStore() =3D default;
 =

-std::future<KSecretsBackend::OpenResult> KSecretsBackend::open(std::string=
&& path, bool readonly /* =3Dtrue */) noexcept
+std::future<KSecretsStore::OpenResult> KSecretsStore::open(std::string&& p=
ath, bool readonly /* =3Dtrue */) noexcept
 {
     // sanity checks
     if (path.empty()) {
@@ -72,20 +72,20 @@ std::future<KSecretsBackend::OpenResult> KSecretsBacken=
d::open(std::string&& pat
     auto localThis =3D this;
     if (!readonly) {
         return std::async(
-            std::launch::async, [localThis, path, shouldCreateFile]() { re=
turn localThis->d->createFileIfNeededThenDo(path, shouldCreateFile, std::bi=
nd(&KSecretsBackendPrivate::lock_open, localThis->d.get(), path)); });
+            std::launch::async, [localThis, path, shouldCreateFile]() { re=
turn localThis->d->createFileIfNeededThenDo(path, shouldCreateFile, std::bi=
nd(&KSecretsStorePrivate::lock_open, localThis->d.get(), path)); });
     }
     else {
         return std::async(
-            std::launch::deferred, [localThis, path, shouldCreateFile]() {=
 return localThis->d->createFileIfNeededThenDo(path, shouldCreateFile, std:=
:bind(&KSecretsBackendPrivate::open, localThis->d.get(), path)); });
+            std::launch::deferred, [localThis, path, shouldCreateFile]() {=
 return localThis->d->createFileIfNeededThenDo(path, shouldCreateFile, std:=
:bind(&KSecretsStorePrivate::open, localThis->d.get(), path)); });
     }
 }
 =

-KSecretsBackend::OpenResult KSecretsBackendPrivate::createFileIfNeededThen=
Do(const std::string& path, bool shouldCreateFile, open_action action)
+KSecretsStore::OpenResult KSecretsStorePrivate::createFileIfNeededThenDo(c=
onst std::string& path, bool shouldCreateFile, open_action action)
 {
     if (shouldCreateFile) {
         auto createRes =3D createFile(path);
         if (createRes !=3D 0) {
-            return setOpenStatus({ KSecretsBackend::OpenStatus::SystemErro=
r, createRes });
+            return setOpenStatus({ KSecretsStore::OpenStatus::SystemError,=
 createRes });
         }
     }
     return action(path);
@@ -94,7 +94,7 @@ KSecretsBackend::OpenResult KSecretsBackendPrivate::creat=
eFileIfNeededThenDo(con
 char fileMagic[] =3D { 'k', 's', 'e', 'c', 'r', 'e', 't', 's' };
 constexpr auto fileMagicLen =3D sizeof(fileMagic) / sizeof(fileMagic[0]);
 =

-int KSecretsBackendPrivate::createFile(const std::string& path)
+int KSecretsStorePrivate::createFile(const std::string& path)
 {
     FILE* f =3D fopen(path.c_str(), "w");
     if (f =3D=3D nullptr) {
@@ -103,7 +103,7 @@ int KSecretsBackendPrivate::createFile(const std::strin=
g& path)
 =

     FileHeadStruct emptyFileData;
     memcpy(emptyFileData.magic, fileMagic, fileMagicLen);
-    gcry_randomize(emptyFileData.salt, KSecretsBackend::SALT_SIZE, GCRY_ST=
RONG_RANDOM);
+    gcry_randomize(emptyFileData.salt, KSecretsStore::SALT_SIZE, GCRY_STRO=
NG_RANDOM);
     gcry_randomize(emptyFileData.iv, IV_SIZE, GCRY_STRONG_RANDOM);
 =

     int res =3D 0;
@@ -114,69 +114,69 @@ int KSecretsBackendPrivate::createFile(const std::str=
ing& path)
     return res;
 }
 =

-const char* KSecretsBackend::salt() const { return d->salt(); }
+const char* KSecretsStore::salt() const { return d->salt(); }
 =

-const char* KSecretsBackendPrivate::salt() const { return fileHead_.salt; }
+const char* KSecretsStorePrivate::salt() const { return fileHead_.salt; }
 =

-KSecretsBackend::OpenResult KSecretsBackendPrivate::lock_open(const std::s=
tring& path)
+KSecretsStore::OpenResult KSecretsStorePrivate::lock_open(const std::strin=
g& path)
 {
     file_ =3D fopen(path.c_str(), "w+");
     if (file_ =3D=3D nullptr) {
-        return { KSecretsBackend::OpenStatus::SystemError, errno };
+        return { KSecretsStore::OpenStatus::SystemError, errno };
     }
     // TODO perform the lock here
     return open(path);
 }
 =

-KSecretsBackend::OpenResult KSecretsBackendPrivate::setOpenStatus(KSecrets=
Backend::OpenResult openStatus)
+KSecretsStore::OpenResult KSecretsStorePrivate::setOpenStatus(KSecretsStor=
e::OpenResult openStatus)
 {
     openStatus_ =3D openStatus;
     return openStatus;
 }
 =

-KSecretsBackend::OpenResult KSecretsBackendPrivate::open(const std::string=
& path)
+KSecretsStore::OpenResult KSecretsStorePrivate::open(const std::string& pa=
th)
 {
     if (file_ =3D=3D nullptr) {
         file_ =3D fopen(path.c_str(), "r");
     }
     if (file_ =3D=3D nullptr) {
-        return setOpenStatus({ KSecretsBackend::OpenStatus::SystemError, e=
rrno });
+        return setOpenStatus({ KSecretsStore::OpenStatus::SystemError, err=
no });
     }
     if (fread(&fileHead_, sizeof(fileHead_), 1, file_) !=3D sizeof(fileHea=
d_)) {
-        return setOpenStatus({ KSecretsBackend::OpenStatus::SystemError, f=
error(file_) });
+        return setOpenStatus({ KSecretsStore::OpenStatus::SystemError, fer=
ror(file_) });
     }
     if (memcmp(fileHead_.magic, fileMagic, fileMagicLen) !=3D 0) {
-        return setOpenStatus({ KSecretsBackend::OpenStatus::InvalidFile, 0=
 });
+        return setOpenStatus({ KSecretsStore::OpenStatus::InvalidFile, 0 }=
);
     }
     // decrypting will occur upon collection request
-    return setOpenStatus({ KSecretsBackend::OpenStatus::Good, 0 });
+    return setOpenStatus({ KSecretsStore::OpenStatus::Good, 0 });
 }
 =

-KSecretsBackend::CollectionNames KSecretsBackend::dirCollections() const n=
oexcept
+KSecretsStore::CollectionNames KSecretsStore::dirCollections() const noexc=
ept
 {
     // TODO
     return CollectionNames();
 }
 =

-KSecretsBackend::CollectionPtr KSecretsBackend::createCollection(std::stri=
ng&&) noexcept
+KSecretsStore::CollectionPtr KSecretsStore::createCollection(std::string&&=
) noexcept
 {
     // TODO
     return CollectionPtr();
 }
 =

-KSecretsBackend::CollectionPtr KSecretsBackend::readCollection(std::string=
&&) const noexcept
+KSecretsStore::CollectionPtr KSecretsStore::readCollection(std::string&&) =
const noexcept
 {
     // TODO
     return CollectionPtr();
 }
 =

-bool KSecretsBackend::deleteCollection(CollectionPtr) noexcept
+bool KSecretsStore::deleteCollection(CollectionPtr) noexcept
 {
     // TODO
     return false;
 }
 =

-bool KSecretsBackend::deleteCollection(std::string&&) noexcept
+bool KSecretsStore::deleteCollection(std::string&&) noexcept
 {
     // TODO
     return false;
diff --git a/src/runtime/ksecrets_store/ksecrets_backend.h b/src/runtime/ks=
ecrets_store/ksecrets_store.h
similarity index 96%
rename from src/runtime/ksecrets_store/ksecrets_backend.h
rename to src/runtime/ksecrets_store/ksecrets_store.h
index c7068e1..db6d65a 100644
--- a/src/runtime/ksecrets_store/ksecrets_backend.h
+++ b/src/runtime/ksecrets_store/ksecrets_store.h
@@ -30,7 +30,7 @@
 #include <array>
 #include <future>
 =

-class KSecretsBackendPrivate;
+class KSecretsStorePrivate;
 =

 /**
  * Secrets storage for KSecrets Service.
@@ -69,7 +69,7 @@ class KSecretsBackendPrivate;
  *       By providing a class, one could use local variables and the class
  *       would be destroyed, releasing the file, upon block exit.
  */
-class KSECRETS_BACKEND_EXPORT KSecretsBackend {
+class KSECRETS_BACKEND_EXPORT KSecretsStore {
     class ItemPrivate;
     class CollectionPrivate;
 =

@@ -106,7 +106,7 @@ public:
         std::time_t modifiedTime() const noexcept;
     protected:
         Item();
-        friend class KSecretsBackend;
+        friend class KSecretsStore;
 =

     private:
         std::shared_ptr<ItemPrivate> d;
@@ -168,7 +168,7 @@ public:
 =

     protected:
         Collection();
-        friend class KSecretsBackend;
+        friend class KSecretsStore;
 =

     private:
         std::shared_ptr<CollectionPrivate> d;
@@ -184,9 +184,9 @@ public:
      *
      * @see open()
      */
-    KSecretsBackend();
-    KSecretsBackend(const KSecretsBackend&) =3D delete;
-    virtual ~KSecretsBackend();
+    KSecretsStore();
+    KSecretsStore(const KSecretsStore&) =3D delete;
+    virtual ~KSecretsStore();
 =

     enum class OpenStatus {
         NotYetOpened,
@@ -237,7 +237,7 @@ public:
     bool deleteCollection(std::string&&) noexcept;
 =

 private:
-    std::unique_ptr<KSecretsBackendPrivate> d;
+    std::unique_ptr<KSecretsStorePrivate> d;
 };
 =

 #endif
diff --git a/src/runtime/ksecrets_store/ksecrets_backend_p.h b/src/runtime/=
ksecrets_store/ksecrets_store_p.h
similarity index 70%
rename from src/runtime/ksecrets_store/ksecrets_backend_p.h
rename to src/runtime/ksecrets_store/ksecrets_store_p.h
index dbbad7c..25f2de0 100644
--- a/src/runtime/ksecrets_store/ksecrets_backend_p.h
+++ b/src/runtime/ksecrets_store/ksecrets_store_p.h
@@ -21,7 +21,7 @@
 #ifndef KSECRETSBACKEND_P_H
 #define KSECRETSBACKEND_P_H
 =

-#include "ksecrets_backend.h"
+#include "ksecrets_store.h"
 =

 class TimeStamped {
 =

@@ -39,7 +39,7 @@ protected:
     {
         // FIXME func may return some value so modify this to take that in=
to account
         func();
-        modifiedTime =3D std::time(nullptr);
+        modifiedTime_ =3D std::time(nullptr);
     };
 =

 private:
@@ -53,32 +53,32 @@ class KSecretsItemPrivate : public TimeStamped {
 class KSecretsCollectionPrivate : public TimeStamped {
 };
 =

-class KSecretsBackendPrivate {
+class KSecretsStorePrivate {
 public:
-    KSecretsBackendPrivate() =3D delete;
-    explicit KSecretsBackendPrivate(KSecretsBackend*);
+    KSecretsStorePrivate() =3D delete;
+    explicit KSecretsStorePrivate(KSecretsStore*);
 =

-    KSecretsBackend::OpenResult lock_open(const std::string&);
-    KSecretsBackend::OpenResult open(const std::string&);
-    using open_action =3D std::function<KSecretsBackend::OpenResult(const =
std::string&)>;
-    KSecretsBackend::OpenResult createFileIfNeededThenDo(const std::string=
&, bool, open_action);
+    KSecretsStore::OpenResult lock_open(const std::string&);
+    KSecretsStore::OpenResult open(const std::string&);
+    using open_action =3D std::function<KSecretsStore::OpenResult(const st=
d::string&)>;
+    KSecretsStore::OpenResult createFileIfNeededThenDo(const std::string&,=
 bool, open_action);
     int createFile(const std::string&);
     const char* salt() const;
 =

     constexpr static auto IV_SIZE =3D 32;
     struct FileHeadStruct {
         char magic[9];
-        char salt[KSecretsBackend::SALT_SIZE];
+        char salt[KSecretsStore::SALT_SIZE];
         char iv[IV_SIZE];
     };
 =

-    KSecretsBackend::OpenResult setOpenStatus(KSecretsBackend::OpenResult);
-    bool isOpen() const noexcept { return KSecretsBackend::OpenStatus::Goo=
d =3D=3D openStatus_.status_; }
+    KSecretsStore::OpenResult setOpenStatus(KSecretsStore::OpenResult);
+    bool isOpen() const noexcept { return KSecretsStore::OpenStatus::Good =
=3D=3D openStatus_.status_; }
 =

-    KSecretsBackend* b_;
+    KSecretsStore* b_;
     FILE* file_;
     FileHeadStruct fileHead_;
-    KSecretsBackend::OpenResult openStatus_;
+    KSecretsStore::OpenResult openStatus_;
 };
 =

 #endif