Use version mappings to get doc id from an version

apache · jiangpengcheng · Sep 15, 2020 · Sep 28, 2020 · Sep 29, 2020 · Oct 9, 2020
commit a3939ed010069bffa0e33d2cfb4155668a7be1b2
diff --git a/ansible/files/whisks_design_document_for_entities_db_v2.1.0.json b/ansible/files/whisks_design_document_for_entities_db_v2.1.0.json
@@ -23,7 +23,7 @@
       "reduce": "_count"
     },
     "action-versions": {
-      "map": "function (doc) {\n  var isAction = function (doc) { return (doc.exec !== undefined) };\n  if (isAction(doc)) try {\n    var value = {\n      _id: doc.namespace + \"/\" + doc.name + \"/default\",\n      namespace: doc.namespace,\n      name: doc.name,\n      version: doc.version\n    };\n    emit([doc.namespace + \"/\" + doc.name], value);\n  } catch (e) {}\n}"
+      "map": "function (doc) {\n  var isAction = function (doc) { return (doc.exec !== undefined) };\n  if (isAction(doc)) try {\n    var value = {\n      _id: doc.namespace + \"/\" + doc.name + \"/default\",\n      namespace: doc.namespace,\n      name: doc.name,\n      docId: doc._id,\n      version: doc.version\n    };\n    emit([doc.namespace + \"/\" + doc.name], value);\n  } catch (e) {}\n}"
     }
   }
 }
diff --git a/common/scala/src/main/scala/org/apache/openwhisk/core/database/DocumentHandler.scala b/common/scala/src/main/scala/org/apache/openwhisk/core/database/DocumentHandler.scala
@@ -211,7 +211,7 @@ object WhisksHandler extends SimpleHandler {
   val FULL_NAME = "fullname"
   private val commonFields = Set("namespace", "name", "version", "publish", "annotations", "updated")
   private val actionFields = commonFields ++ Set("limits", "exec.binary")
-  private val actionVersionFields = commonFields ++ Set("_id")
+  private val actionVersionFields = commonFields ++ Set("_id", "docId")
   private val packageFields = commonFields ++ Set("binding")
   private val packagePublicFields = commonFields
   private val ruleFields = commonFields
@@ -308,7 +308,7 @@ object WhisksHandler extends SimpleHandler {
   private def computeActionVersionsView(js: JsObject): JsObject = {
     val base = js.fields.filterKeys(actionVersionFields).toMap
     val defaultId = js.fields("namespace") + "/" + js.fields("name") + "/default"
-    JsObject(base + ("_id" -> JsString(defaultId)))
+    JsObject(base + ("_id" -> JsString(defaultId), "docId" -> js.fields("_id")))
   }
 }
 

diff --git a/common/scala/src/main/scala/org/apache/openwhisk/core/entity/WhiskAction.scala b/common/scala/src/main/scala/org/apache/openwhisk/core/entity/WhiskAction.scala
@@ -362,16 +362,16 @@ case class ExecutableWhiskActionMetaData(namespace: EntityPath,
 
 case class WhiskActionVersionList(namespace: EntityPath,
                                   name: EntityName,
-                                  versions: List[SemVer],
+                                  versionMappings: Map[SemVer, DocId],
                                   defaultVersion: Option[SemVer]) {
   def matchedDocId(version: Option[SemVer]): Option[DocId] = {
     (version, defaultVersion) match {
       case (Some(ver), _) =>
-        Some(DocId(s"$namespace/$name@$ver"))
+        versionMappings.get(ver)
       case (None, Some(default)) =>
-        Some(DocId(s"$namespace/$name@$default"))
-      case (None, None) if versions.nonEmpty =>
-        Some(DocId(s"$namespace/$name@${versions.max}"))
+        versionMappings.get(default)
+      case (None, None) if versionMappings.nonEmpty =>
+        Some(versionMappings.maxBy(_._1)._2)
       case _ =>
         None
     }
@@ -413,7 +413,14 @@ object WhiskActionVersionList extends MultipleReadersSingleWriterCache[WhiskActi
             row.fields("value").asJsObject()
           }
           val versions = values.map { value =>
-            Try { value.fields.get("version").map(_.convertTo[SemVer]) } getOrElse None
+            val docId = value.fields.get("docId").map(_.compactPrint)
+            val version = Try { value.fields.get("version").map(_.convertTo[SemVer]) } getOrElse None
+            (version, docId) match {
+              case (Some(ver), Some(id)) =>
+                Some((ver, DocId(id)))
+              case _ =>
+                None
+            }
           }
 
           val defaultVersion = if (result.nonEmpty) {
@@ -422,7 +429,7 @@ object WhiskActionVersionList extends MultipleReadersSingleWriterCache[WhiskActi
               case None        => None
             }
           } else None
-          WhiskActionVersionList(action.path, action.name, versions.filter(_.nonEmpty).map(_.get), defaultVersion)
+          WhiskActionVersionList(action.path, action.name, versions.filter(_.nonEmpty).map(_.get).toMap, defaultVersion)
         },
       fromCache)
   }

diff --git a/core/controller/src/main/scala/org/apache/openwhisk/core/controller/Actions.scala b/core/controller/src/main/scala/org/apache/openwhisk/core/controller/Actions.scala
@@ -222,32 +222,32 @@ trait WhiskActionsApi extends WhiskCollectionAPI with PostActionActivation with
   override def create(user: Identity, entityName: FullyQualifiedEntityName)(implicit transid: TransactionId) = {
     parameter('overwrite ? false, 'deleteOld ? false, 'defaultVersion.as[String] ? "") {
       (overwrite, deleteOld, defaultVersion) =>
-        entity(as[WhiskActionPut]) { content =>
-          Try {
-            SemVer(defaultVersion)
-          } match {
-            case Success(version) =>
-              onComplete(WhiskActionVersionList.get(entityName, entityStore, false)) {
-                case Success(result) if (result.versions.contains(version)) =>
-                  val dv = WhiskActionDefaultVersion(entityName.path, entityName.name, Some(version))
-                  putEntity(
-                    WhiskActionDefaultVersion,
-                    entityStore,
-                    dv.docid,
-                    true,
-                    (old: WhiskActionDefaultVersion) =>
-                      Future.successful(dv.revision[WhiskActionDefaultVersion](old.rev)),
-                    () => Future.successful(dv),
-                    postProcess = Some { version: WhiskActionDefaultVersion =>
-                      WhiskActionVersionList.deleteCache(entityName)
-                      complete(OK, version)
-                    })
-                case Success(_) =>
-                  terminate(Forbidden, s"[PUT] entity doesn't has version $version")
-                case Failure(_) =>
-                  terminate(InternalServerError)
-              }
-            case Failure(_) =>
+        Try {
+          SemVer(defaultVersion)
+        } match {
+          case Success(version) =>
+            onComplete(WhiskActionVersionList.get(entityName, entityStore, false)) {
+              case Success(result) if (result.versionMappings.contains(version)) =>
+                val dv = WhiskActionDefaultVersion(entityName.path, entityName.name, Some(version))
+                putEntity(
+                  WhiskActionDefaultVersion,
+                  entityStore,
+                  dv.docid,
+                  true,
+                  (old: WhiskActionDefaultVersion) =>
+                    Future.successful(dv.revision[WhiskActionDefaultVersion](old.rev)),
+                  () => Future.successful(dv),
+                  postProcess = Some { version: WhiskActionDefaultVersion =>
+                    WhiskActionVersionList.deleteCache(entityName)
+                    complete(OK, version)
+                  })
+              case Success(_) =>
+                terminate(Forbidden, s"[PUT] entity doesn't has version $version")
+              case Failure(_) =>
+                terminate(InternalServerError)
+            }
+          case Failure(_) =>
+            entity(as[WhiskActionPut]) { content =>
               val request = content.resolve(user.namespace)
               val checkAdditionalPrivileges = entitleReferencedEntities(user, Privilege.READ, request.exec).flatMap {
                 case _ => entitlementProvider.check(user, content.exec)
@@ -256,10 +256,10 @@ trait WhiskActionsApi extends WhiskCollectionAPI with PostActionActivation with
               onComplete(checkAdditionalPrivileges) {
                 case Success(_) =>
                   onComplete(WhiskActionVersionList.get(entityName, entityStore, false)) {
-                    case Success(result) if (result.versions.size >= actionMaxVersionLimit && !deleteOld) =>
+                    case Success(result) if (result.versionMappings.size >= actionMaxVersionLimit && !deleteOld) =>
                       terminate(
                         Forbidden,
-                        s"[PUT] entity has ${result.versions.size} versions exist which exceed $actionMaxVersionLimit, delete one of them before create new one or pass deleteOld=true to delete oldest version automatically")
+                        s"[PUT] entity has ${result.versionMappings.size} versions exist which exceed maximum limit, delete one of them before create new one or pass deleteOld=true to delete oldest version automatically")
                     case Success(result) =>
                       val id = result.matchedDocId(None).getOrElse(entityName.toDocId)
                       putEntity(
@@ -273,10 +273,10 @@ trait WhiskActionsApi extends WhiskCollectionAPI with PostActionActivation with
                         },
                         postProcess = Some { action: WhiskAction =>
                           // delete oldest version when created successfully
-                          if (result.versions.size >= actionMaxVersionLimit) {
-                            val id = entityName.copy(version = Some(result.versions.min)).asString
-                            WhiskAction.get(entityStore, DocId(id)) flatMap { entity =>
-                              WhiskAction.del(entityStore, DocInfo ! (id, entity.rev.rev)).map(_ => entity)
+                          if (result.versionMappings.size >= actionMaxVersionLimit) {
+                            val docid = result.versionMappings.minBy(_._1)._2
+                            WhiskAction.get(entityStore, docid) flatMap { entity =>
+                              WhiskAction.del(entityStore, DocInfo ! (docid.id, entity.rev.rev)).map(_ => entity)
                             } andThen {
                               case _ =>
                                 WhiskActionVersionList.deleteCache(entityName)
@@ -292,7 +292,7 @@ trait WhiskActionsApi extends WhiskCollectionAPI with PostActionActivation with
                 case Failure(f) =>
                   super.handleEntitlementFailure(f)
               }
-          }
+            }
         }
     }
   }
@@ -416,27 +416,26 @@ trait WhiskActionsApi extends WhiskCollectionAPI with PostActionActivation with
                 (a: WhiskAction) => Future.successful({}),
                 postProcess = Some { action: WhiskAction =>
                   // when default version is deleted or all versions are deleted, delete the default version entity
-                  if (version == results.defaultVersion || results.versions.size == 1)
+                  if (version == results.defaultVersion || results.versionMappings.size == 1)
                     deleteDefaultVersion(
                       WhiskActionDefaultVersion(entityName.path, entityName.name, results.defaultVersion))
                   WhiskActionVersionList.deleteCache(entityName)
                   complete(OK, action)
                 })
-            case None if !deleteAll && results.versions.size > 1 =>
+            case None if !deleteAll && results.versionMappings.size > 1 =>
               terminate(
                 Forbidden,
                 s"[DEL] entity version not provided, you need to specify deleteAll=true to delete all versions for action $entityName")
             case None =>
               val fs =
-                if (results.versions.isEmpty)
+                if (results.versionMappings.isEmpty)
                   Seq(WhiskAction.get(entityStore, entityName.toDocId) flatMap { entity =>
                     WhiskAction.del(entityStore, entity.docinfo).map(_ => entity)
                   })
                 else
-                  results.versions.map { version =>
-                    val id = entityName.copy(version = Some(version)).asString
-                    WhiskAction.get(entityStore, DocId(id)) flatMap { entity =>
-                      WhiskAction.del(entityStore, DocInfo ! (id, entity.rev.rev)).map(_ => entity)
+                  results.versionMappings.values.map { docid =>
+                    WhiskAction.get(entityStore, docid) flatMap { entity =>
+                      WhiskAction.del(entityStore, DocInfo ! (docid.id, entity.rev.rev)).map(_ => entity)
                     }
                   }
               val deleteFuture = Future.sequence(fs).andThen {

diff --git a/tools/migrate/migrate_to_new_id.py b/tools/migrate/migrate_to_new_id.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python
-"""Python script to delete old Activations.
+"""
 /*
  * Licensed to the Apache Software Foundation (ASF) under one or more
  * contributor license agreements.  See the NOTICE file distributed with
@@ -26,7 +26,7 @@
 
 if __name__ == '__main__':
     parser = argparse.ArgumentParser(description="Utility to migrate actions with new ids.")
-    parser.add_argument("--dbUrl", required=True, help="Server URL of the database, that has to be cleaned of old activations. E.g. 'https://xxx:yyy@domain.couch.com:443'")
+    parser.add_argument("--dbUrl", required=True, help="Server URL of the database. E.g. 'https://xxx:yyy@domain.couch.com:443'")
     parser.add_argument("--dbName", required=True, help="Name of the Database of the actions to be migration.")
     parser.add_argument("--docsPerRequest", type=int, default=200, help="Number of documents handled on each CouchDb Request. Default is 200.")