EMSUSD-1098 Fixed saving vs locked layers

lib/mayaUsd/nodes/layerManager.cpp

@@ -159,27 +159,19 @@ void convertAnonymousLayersRecursive(
 {
     auto currentTarget = stage->GetEditTarget().GetLayer();
 
-    MayaUsd::utils::LayerParent parentPtr;
-    if (stage->GetRootLayer() == layer) {
-        parentPtr._layerParent = nullptr;
-        parentPtr._proxyPath = basename;
-    } else if (stage->GetSessionLayer() == layer) {
-        parentPtr._layerParent = nullptr;
-        parentPtr._proxyPath = basename;
-    } else {
-        parentPtr._layerParent = layer;
-        parentPtr._proxyPath = basename;
-    }
-
     std::vector<std::string> sublayers = layer->GetSubLayerPaths();
     for (size_t i = 0, n = sublayers.size(); i < n; ++i) {
-        auto subL = layer->Find(sublayers[i]);
+        SdfLayerRefPtr subL = layer->Find(sublayers[i]);
         if (subL) {
             convertAnonymousLayersRecursive(subL, basename, stage);
 
             if (subL->IsAnonymous()) {
-                auto newLayer
-                    = MayaUsd::utils::saveAnonymousLayer(stage, subL, parentPtr, basename);
+                MayaUsd::utils::LayerParent subLayerParent;
+                subLayerParent._layerParent = layer;
+                subLayerParent._proxyPath = basename;
+
+                SdfLayerRefPtr newLayer
+                    = MayaUsd::utils::saveAnonymousLayer(stage, subL, subLayerParent, basename);
                 if (subL == currentTarget) {
                     stage->SetEditTarget(newLayer);
                 }

lib/mayaUsd/python/CMakeLists.txt

@@ -33,6 +33,7 @@ target_sources(${PYTHON_TARGET_NAME}
         wrapConverter.cpp
         wrapCopyLayerPrims.cpp
         wrapDiagnosticDelegate.cpp
+        wrapLayerLocking.cpp
         wrapLoadRules.cpp
         wrapMeshWriteUtils.cpp
         wrapOpUndoItem.cpp

lib/mayaUsd/python/module.cpp

@@ -31,6 +31,7 @@ TF_WRAP_MODULE
     TF_WRAP(ConverterArgs);
     TF_WRAP(CopyLayerPrims);
     TF_WRAP(DiagnosticDelegate);
+    TF_WRAP(LayerLocking);
     TF_WRAP(LoadRules);
     TF_WRAP(MeshWriteUtils);
 #ifdef UFE_V3_FEATURES_AVAILABLE

lib/mayaUsd/python/wrapLayerLocking.cpp

@@ -0,0 +1,65 @@
+//
+// Copyright 2023 Autodesk
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include <mayaUsd/utils/layerLocking.h>
+
+#include <pxr/base/tf/pyResultConversions.h>
+
+#include <boost/python/def.hpp>
+
+using namespace boost::python;
+
+namespace {
+
+void _lockLayer(const std::string& shapeName, PXR_NS::SdfLayer& layer)
+{
+    PXR_NS::SdfLayerRefPtr layerPtr(&layer);
+    MayaUsd::lockLayer(shapeName, layerPtr, MayaUsd::LayerLock_Locked);
+}
+
+void _systemLockLayer(const std::string& shapeName, PXR_NS::SdfLayer& layer)
+{
+    PXR_NS::SdfLayerRefPtr layerPtr(&layer);
+    MayaUsd::lockLayer(shapeName, layerPtr, MayaUsd::LayerLock_SystemLocked);
+}
+
+void _unlockLayer(const std::string& shapeName, PXR_NS::SdfLayer& layer)
+{
+    PXR_NS::SdfLayerRefPtr layerPtr(&layer);
+    MayaUsd::lockLayer(shapeName, layerPtr, MayaUsd::LayerLock_Unlocked);
+}
+
+bool _isLayerLocked(PXR_NS::SdfLayer& layer)
+{
+    PXR_NS::SdfLayerRefPtr layerPtr(&layer);
+    return MayaUsd::isLayerLocked(layerPtr);
+}
+
+bool _isLayerSystemLocked(PXR_NS::SdfLayer& layer)
+{
+    PXR_NS::SdfLayerRefPtr layerPtr(&layer);
+    return MayaUsd::isLayerSystemLocked(layerPtr);
+}
+
+} // namespace
+
+void wrapLayerLocking()
+{
+    def("lockLayer", _lockLayer);
+    def("systemLockLayer", _systemLockLayer);
+    def("unlockLayer", _unlockLayer);
+    def("isLayerLocked", _isLayerLocked);
+    def("isLayerSystemLocked", _isLayerSystemLocked);
+}

lib/mayaUsd/utils/layerLocking.h

@@ -97,7 +97,8 @@ enum LayerLockType
     LayerLock_SystemLocked
 };
 
-/*! \brief Sets the lock status on a layer
+/*! \brief Sets the lock status on a layer.
+ *         Automatically calls addLockedLayer, addSystemLockedLayer or their remove counterparts.
  */
 MAYAUSD_CORE_PUBLIC
 void lockLayer(

lib/mayaUsd/utils/utilFileSystem.cpp

@@ -750,3 +750,56 @@ std::string UsdMayaUtilFileSystem::pathFindExtension(std::string& filePath)
     ghc::filesystem::path ext = p.extension();
     return ext.string();
 }
+
+UsdMayaUtilFileSystem::FileBackup::FileBackup(const std::string& filename)
+    : _filename(filename)
+{
+    backup();
+}
+
+UsdMayaUtilFileSystem::FileBackup::~FileBackup()
+{
+    // If commited, we don't restore the old file.
+    if (_commited)
+        return;
+
+    try {
+        restore();
+    } catch (...) {
+        // Don't allow exceptions out of a destructor.
+    }
+}
+
+std::string UsdMayaUtilFileSystem::FileBackup::getBackupFilename() const
+{
+    return _filename + ".backup";
+}
+
+void UsdMayaUtilFileSystem::FileBackup::backup()
+{
+    if (!ghc::filesystem::exists(ghc::filesystem::path(_filename)))
+        return;
+
+    const std::string backupFileName = getBackupFilename();
+    remove(backupFileName.c_str());
+    if (rename(_filename.c_str(), backupFileName.c_str()) != 0)
+        return;
+
+    _backed = true;
+}
+
+void UsdMayaUtilFileSystem::FileBackup::commit()
+{
+    // Once commited, the backup will not be put back into the original file.
+    _commited = true;
+}
+
+void UsdMayaUtilFileSystem::FileBackup::restore()
+{
+    if (!_backed)
+        return;
+
+    remove(_filename.c_str());
+    const std::string backupFileName = getBackupFilename();
+    rename(backupFileName.c_str(), _filename.c_str());
+}

lib/mayaUsd/utils/utilFileSystem.h

@@ -308,6 +308,30 @@ void pathRemoveExtension(std::string& filePath);
 MAYAUSD_CORE_PUBLIC
 std::string pathFindExtension(std::string& filePath);
 
+// Backup a file and restore it if not commited.
+class FileBackup
+{
+public:
+    FileBackup(const std::string& filename);
+    ~FileBackup();
+
+    // Once commited, the backup will not be put back into the original file.
+    void commit();
+
+    // Force restoration of the original file if successfully backed-up, even if commited.
+    void restore();
+
+    // Return the backup file name.
+    std::string getBackupFilename() const;
+
+public:
+    void backup();
+
+    std::string _filename;
+    bool        _backed = false;
+    bool        _commited = false;
+};
+
 } // namespace UsdMayaUtilFileSystem
 
 PXR_NAMESPACE_CLOSE_SCOPE