4798

pending completion

Build # 4798

Build Type

push

travis-ci

Committed by

web-flow

Commit Message

<a href="https://github.com/broadinstitute/firecloud-orchestration/commit/<a class=hub.com/broadinstitute/firecloud-orchestration/commit/6799e85876ef879c929f16e5ac78589d6a15da24">6799e8587<a href="https://github.com/broadinstitute/firecloud-orchestration/commit/6799e85876ef879c929f16e5ac78589d6a15da24">&quot;&gt;mtalbott add me param (#670)

* add parameter to routes; add UserRegistrationInfoV2 case class

* fix ordering of parameter and get in UserApiService; make RegistrationInfoV2 unmarshallable; now doesn&amp;#39;t break everything

* change name of parameter to make function more clear; add tests for endpoint with parameter

* pull nested case statements out into separate methods

* pull duplicated mocking code out into single method

* remove accidental import

* update swagger docs

* revert back to original /me endpoint in attempt to fix UI failing

* another effort at fixing the errors in the UI

* return /me endpoint to develop state

* Revert &amp;quot;update swagger docs&quot;

This reverts commit </a><a class="double-link" href="https://github.com/broadinstitute/firecloud-orchestration/commit/<a class="double-link" href="https://github.com/broadinstitute/firecloud-orchestration/commit/5a089bf54475eda3459181ab9998db881a89c67d">5a089bf54</a>">5a089bf54</a><a href="https://github.com/broadinstitute/firecloud-orchestration/commit/6799e85876ef879c929f16e5ac78589d6a15da24">.

* reverted to wrong commit so just fixed it manually

* remove unused function

* change /me endpoint to only use v2 endpoints in sam when supporting v1

* add correct case class for v2 workbench user diagnostics payload

Run Details

41 of 41 new or added lines in 2 files covered. (100.0%)

2742 of 4088 relevant lines covered (67.07%)

0.67 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

64.0

/src/main/scala/org/broadinstitute/dsde/firecloud/service/LibraryService.scala

package org.broadinstitute.dsde.firecloud.service

import akka.actor.{Actor, Props}
import akka.pattern._
import com.typesafe.scalalogging.LazyLogging
import org.broadinstitute.dsde.firecloud.{Application, FireCloudConfig, FireCloudException, FireCloudExceptionWithErrorReport}
import org.broadinstitute.dsde.firecloud.dataaccess._
import org.broadinstitute.dsde.rawls.model._
import org.broadinstitute.dsde.firecloud.model._
import org.broadinstitute.dsde.firecloud.service.LibraryService._
import org.broadinstitute.dsde.firecloud.service.PerRequest.{PerRequestMessage, RequestComplete}
import org.broadinstitute.dsde.firecloud.utils.PermissionsSupport
import org.everit.json.schema.ValidationException
import org.slf4j.LoggerFactory
import spray.json._
import spray.json.DefaultJsonProtocol._
import spray.http.StatusCodes._
import spray.httpx.SprayJsonSupport
import spray.json.JsonParser.ParsingException
import org.broadinstitute.dsde.firecloud.model.ModelJsonProtocol.{impLibraryBulkIndexResponse, impLibrarySearchResponse}
import org.broadinstitute.dsde.rawls.model.WorkspaceJsonSupport.{AttributeNameFormat, WorkspaceFormat}
import org.broadinstitute.dsde.rawls.model.Attributable.AttributeMap
import org.broadinstitute.dsde.rawls.model.AttributeUpdateOperations.{AddListMember, AttributeUpdateOperation, RemoveAttribute}

import scala.concurrent.{ExecutionContext, Future}
import scala.util.{Failure, Success, Try}

object LibraryService {
  final val publishedFlag = AttributeName.withLibraryNS("published")
  final val discoverableWSAttribute = AttributeName.withLibraryNS("discoverableByGroups")
  final val orspIdAttribute = AttributeName.withLibraryNS("orsp")
  final val schemaLocation = "library/attribute-definitions.json"

  sealed trait LibraryServiceMessage
  case class UpdateLibraryMetadata(ns: String, name: String, attrsJsonString: String, validate: Boolean) extends LibraryServiceMessage
  case class GetLibraryMetadata(ns: String, name: String) extends LibraryServiceMessage
  case class UpdateDiscoverableByGroups(ns: String, name: String, newGroups: Seq[String]) extends LibraryServiceMessage
  case class GetDiscoverableByGroups(ns: String, name: String) extends LibraryServiceMessage
  case class SetPublishAttribute(ns: String, name: String, value: Boolean) extends LibraryServiceMessage
  case object IndexAll extends LibraryServiceMessage
  case class FindDocuments(criteria: LibrarySearchParams) extends LibraryServiceMessage
  case class Suggest(criteria: LibrarySearchParams) extends LibraryServiceMessage
  case class PopulateSuggest(field: String, text: String) extends LibraryServiceMessage

  def props(libraryServiceConstructor: UserInfo => LibraryService, userInfo: UserInfo): Props = {
    Props(libraryServiceConstructor(userInfo))
  }

  def constructor(app: Application)(userInfo: UserInfo)(implicit executionContext: ExecutionContext) =
    new LibraryService(userInfo, app.rawlsDAO, app.samDAO, app.searchDAO, app.ontologyDAO, app.consentDAO)
}


class LibraryService (protected val argUserInfo: UserInfo,
                      val rawlsDAO: RawlsDAO,
                      val samDao: SamDAO,
                      val searchDAO: SearchDAO,
                      val ontologyDAO: OntologyDAO,
                      val consentDAO: ConsentDAO)
                     (implicit protected val executionContext: ExecutionContext) extends Actor
  with LibraryServiceSupport with AttributeSupport with PermissionsSupport with SprayJsonSupport with LazyLogging with WorkspacePublishingSupport {

  lazy val log = LoggerFactory.getLogger(getClass)

  implicit val userToken = argUserInfo

  // attributes come in as standard json so we can use json schema for validation. Thus,
  // we need to use the plain-array deserialization.
  implicit val impAttributeFormat: AttributeFormat = new AttributeFormat with PlainArrayAttributeListSerializer

  override def receive = {
    case UpdateLibraryMetadata(ns: String, name: String, attrsJsonString: String, validate: Boolean) => updateLibraryMetadata(ns, name, attrsJsonString, validate) pipeTo sender
    case GetLibraryMetadata(ns: String, name: String) => getLibraryMetadata(ns, name) pipeTo sender
    case UpdateDiscoverableByGroups(ns: String, name: String, newGroups: Seq[String]) => updateDiscoverableByGroups(ns, name, newGroups) pipeTo sender
    case GetDiscoverableByGroups(ns: String, name: String) => getDiscoverableByGroups(ns, name) pipeTo sender
    case SetPublishAttribute(ns: String, name: String, value: Boolean) => setWorkspaceIsPublished(ns, name, value) pipeTo sender
    case IndexAll => asAdmin {indexAll} pipeTo sender
    case FindDocuments(criteria: LibrarySearchParams) => findDocuments(criteria) pipeTo sender
    case Suggest(criteria: LibrarySearchParams) => suggest(criteria) pipeTo sender
    case PopulateSuggest(field: String, text: String) => populateSuggest(field: String, text: String) pipeTo sender
  }


  def updateDiscoverableByGroups(ns: String, name: String, newGroups: Seq[String]): Future[PerRequestMessage] = {
    if (newGroups.forall { g => FireCloudConfig.ElasticSearch.discoverGroupNames.contains(g) }) {
      rawlsDAO.getWorkspace(ns, name) flatMap { workspaceResponse =>
        // this is technically vulnerable to a race condition in which the workspace attributes have changed
        // between the time we retrieved them and here, where we update them.
        val remove = Seq(RemoveAttribute(discoverableWSAttribute))
        val operations = newGroups map (group => AddListMember(discoverableWSAttribute, AttributeString(group)))
          internalPatchWorkspaceAndRepublish(ns, name, remove ++ operations, isPublished(workspaceResponse)) map (RequestComplete(_))
      }
    } else {
      Future(RequestCompleteWithErrorReport(BadRequest, s"groups must be subset of allowable groups: %s".format(FireCloudConfig.ElasticSearch.discoverGroupNames.toArray.mkString(", "))))
    }
  }

  def getDiscoverableByGroups(ns: String, name: String): Future[PerRequestMessage] = {
    rawlsDAO.getWorkspace(ns, name) map { workspaceResponse =>
      val groups = workspaceResponse.workspace.attributes.get(discoverableWSAttribute) match {
        case Some(vals:AttributeValueList) => vals.list.collect{
          case s:AttributeString => s.value
        }
        case _ => List.empty[String]
      }
      RequestComplete(OK, groups.sortBy(_.toLowerCase))
    }
  }

  private def isInvalid(attrsJsonString: String): (Boolean, Option[String]) = {
    val validationResult = Try(schemaValidate(attrsJsonString))
    validationResult match {
      case Failure(ve: ValidationException) => (true, Some(getSchemaValidationMessages(ve).mkString("; ")))
      case Failure(e) => (true, Some(e.getMessage))
      case Success(x) => (false, None)
    }
  }

  def updateLibraryMetadata(ns: String, name: String, attrsJsonString: String, validate: Boolean): Future[PerRequestMessage] = {
    // we accept a string here, not a JsValue so we can most granularly handle json parsing

    Try(attrsJsonString.parseJson.asJsObject.convertTo[AttributeMap]) match {
      case Failure(ex:ParsingException) => Future(RequestCompleteWithErrorReport(BadRequest, "Invalid json supplied", ex))
      case Failure(e) => Future(RequestCompleteWithErrorReport(BadRequest, BadRequest.defaultMessage, e))
      case Success(attrs) =>
        val userAttrs = attrs.get(AttributeName.withLibraryNS("dulvn")) match {
          case Some(AttributeNull) | None => attrs ++ Map(AttributeName.withLibraryNS("dulvn") -> AttributeNumber(FireCloudConfig.Duos.dulvn))
          case _ =>  attrs
        }
        val (invalid, errorMessage): (Boolean, Option[String]) = isInvalid(attrsJsonString)
        rawlsDAO.getWorkspace(ns, name) flatMap { workspaceResponse =>
          val published = isPublished(workspaceResponse)
          if (invalid && (published || validate)) {
            Future(RequestCompleteWithErrorReport(BadRequest, errorMessage.getOrElse(BadRequest.defaultMessage)))
          } else {
            // because not all editors can update discoverableByGroups, if the request does not include discoverableByGroups
            // or if it is not being changed, don't include it in the update operations (less restrictive permissions will
            // be checked by rawls)
            val modDiscoverability = userAttrs.contains(discoverableWSAttribute) && isDiscoverableDifferent(workspaceResponse, userAttrs)
            val skipAttributes =
              if (modDiscoverability)
                Seq(publishedFlag)
              else
              // if discoverable by groups is not being changed, then skip it (i.e. don't delete from ws)
                Seq(publishedFlag, discoverableWSAttribute)

            // this is technically vulnerable to a race condition in which the workspace attributes have changed
            // between the time we retrieved them and here, where we update them.
            val allOperations = generateAttributeOperations(workspaceResponse.workspace.attributes, userAttrs,
              k => k.namespace == AttributeName.libraryNamespace && !skipAttributes.contains(k))
            internalPatchWorkspaceAndRepublish(ns, name, allOperations, published) map (RequestComplete(_))
          }
        }
    }
  }

  def getLibraryMetadata(ns: String, name: String): Future[PerRequestMessage] = {
    rawlsDAO.getWorkspace(ns, name) flatMap { workspaceResponse =>
      val allAttrs = workspaceResponse.workspace.attributes
      val libAttrs = allAttrs.filter {
        case ((LibraryService.publishedFlag,v)) => false
        case ((k,v)) if k.namespace == AttributeName.libraryNamespace => true
        case _ => false
      }
      Future(RequestComplete(OK, libAttrs))
    }
  }

  /*
   * Will republish if it is currently in the published state.
   */
  private def internalPatchWorkspaceAndRepublish(ns: String, name: String, allOperations: Seq[AttributeUpdateOperation], isPublished: Boolean): Future[Workspace] = {
      rawlsDAO.updateLibraryAttributes(ns, name, allOperations) map { newws =>
      republishDocument(newws, ontologyDAO, searchDAO, consentDAO)
      newws
    }
  }

  // should only be used to change published state
  def setWorkspaceIsPublished(ns: String, name: String, publishArg: Boolean): Future[PerRequestMessage] = {
    rawlsDAO.getWorkspace(ns, name) flatMap { workspaceResponse =>
      val currentPublished = isPublished(workspaceResponse)
      // only need to validate metadata if we are actually publishing
      val (invalid, errorMessage) = if (publishArg && !currentPublished)
        isInvalid(workspaceResponse.workspace.attributes.toJson.compactPrint)
      else
        (false, None)

      if (currentPublished == publishArg)
        // user request would result in no change; just return as noop.
        Future(RequestComplete(NoContent))
      else if (invalid)
        // user requested a publish, but metadata is invalid; return error.
        Future(RequestCompleteWithErrorReport(BadRequest, errorMessage.getOrElse(BadRequest.defaultMessage)))
      else {
        // user requested a change in published flag, and metadata is valid; make the change.
        setWorkspacePublishedStatus(workspaceResponse.workspace, publishArg, rawlsDAO, ontologyDAO, searchDAO, consentDAO) map { ws =>
          RequestComplete(ws)
        }
      }
    }
  }

  def indexAll: Future[PerRequestMessage] = {
    logger.info("reindex: requesting workspaces from rawls ...")
    rawlsDAO.getAllLibraryPublishedWorkspaces flatMap { workspaces: Seq[Workspace] =>
      if (workspaces.isEmpty)
        Future(RequestComplete(NoContent))
      else {
        logger.info("reindex: requesting ontology parents for workspaces ...")
        val toIndex: Future[Seq[Document]] = indexableDocuments(workspaces, ontologyDAO, consentDAO)
        toIndex map { documents =>
          logger.info("reindex: resetting index ...")
          searchDAO.recreateIndex()
          logger.info("reindex: indexing datasets ...")
          val indexedDocuments = searchDAO.bulkIndex(documents)
          logger.info("reindex: ... done.")
          if (indexedDocuments.hasFailures) {
            RequestComplete(InternalServerError, indexedDocuments)
          } else {
            RequestComplete(OK, indexedDocuments)
          }
        }
      }
    }
  }

  def findDocuments(criteria: LibrarySearchParams): Future[PerRequestMessage] = {
    getEffectiveDiscoverGroups(rawlsDAO) flatMap { userGroups =>
      // we want docsFuture and ids to be parallelized - so declare them here, outside
      // of the for-yield.
      val docsFuture = searchDAO.findDocuments(criteria, userGroups)
      val idsFuture = rawlsDAO.getWorkspaces

      (for {
        docs <- docsFuture
        ids <- idsFuture
      } yield RequestComplete(updateAccess(docs, ids))) recover {
        case ex =>
          throw new FireCloudExceptionWithErrorReport(ErrorReport(errorMessageFromSearchException(ex)))
      }
    }
  }

  def suggest(criteria: LibrarySearchParams): Future[PerRequestMessage] = {
    getEffectiveDiscoverGroups(rawlsDAO) map {userGroups =>
      searchDAO.suggestionsFromAll(criteria, userGroups)} map (RequestComplete(_))
  }

  def populateSuggest(field: String, text: String): Future[PerRequestMessage] = {
    searchDAO.suggestionsForFieldPopulate(field, text) map {RequestComplete(_)} recoverWith {
      case e: FireCloudException => Future(RequestCompleteWithErrorReport(BadRequest, s"suggestions not available for field %s".format(field)))
    }
  }

  private def errorMessageFromSearchException(ex: Throwable): String = {
    // elasticsearch errors are often nested, try to dig into them safely to find a message
    val message = if (ex.getCause != null) {
      val firstCause = ex.getCause
      if (firstCause.getCause != null) {
        firstCause.getCause.getMessage
      } else {
        firstCause.getMessage
      }
    } else {
      ex.getMessage
    }

    Option(message) match {
      case Some(m:String) => m
      case _ => "Unknown error during search."
    }

  }

}

1	package org.broadinstitute.dsde.firecloud.service
2
3	import akka.actor.{Actor, Props}
4	import akka.pattern._
5	import com.typesafe.scalalogging.LazyLogging
6	import org.broadinstitute.dsde.firecloud.{Application, FireCloudConfig, FireCloudException, FireCloudExceptionWithErrorReport}
7	import org.broadinstitute.dsde.firecloud.dataaccess._
8	import org.broadinstitute.dsde.rawls.model._
9	import org.broadinstitute.dsde.firecloud.model._
10	import org.broadinstitute.dsde.firecloud.service.LibraryService._
11	import org.broadinstitute.dsde.firecloud.service.PerRequest.{PerRequestMessage, RequestComplete}
12	import org.broadinstitute.dsde.firecloud.utils.PermissionsSupport
13	import org.everit.json.schema.ValidationException
14	import org.slf4j.LoggerFactory
15	import spray.json._
16	import spray.json.DefaultJsonProtocol._
17	import spray.http.StatusCodes._
18	import spray.httpx.SprayJsonSupport
19	import spray.json.JsonParser.ParsingException
20	import org.broadinstitute.dsde.firecloud.model.ModelJsonProtocol.{impLibraryBulkIndexResponse, impLibrarySearchResponse}
21	import org.broadinstitute.dsde.rawls.model.WorkspaceJsonSupport.{AttributeNameFormat, WorkspaceFormat}
22	import org.broadinstitute.dsde.rawls.model.Attributable.AttributeMap
23	import org.broadinstitute.dsde.rawls.model.AttributeUpdateOperations.{AddListMember, AttributeUpdateOperation, RemoveAttribute}
24
25	import scala.concurrent.{ExecutionContext, Future}
26	import scala.util.{Failure, Success, Try}
27
28	object LibraryService {
29	final val publishedFlag = AttributeName.withLibraryNS("published")	1✔
30	final val discoverableWSAttribute = AttributeName.withLibraryNS("discoverableByGroups")	1✔
31	final val orspIdAttribute = AttributeName.withLibraryNS("orsp")	1✔
32	final val schemaLocation = "library/attribute-definitions.json"	×
33
34	sealed trait LibraryServiceMessage
35	case class UpdateLibraryMetadata(ns: String, name: String, attrsJsonString: String, validate: Boolean) extends LibraryServiceMessage
36	case class GetLibraryMetadata(ns: String, name: String) extends LibraryServiceMessage
37	case class UpdateDiscoverableByGroups(ns: String, name: String, newGroups: Seq[String]) extends LibraryServiceMessage
38	case class GetDiscoverableByGroups(ns: String, name: String) extends LibraryServiceMessage
39	case class SetPublishAttribute(ns: String, name: String, value: Boolean) extends LibraryServiceMessage
40	case object IndexAll extends LibraryServiceMessage
41	case class FindDocuments(criteria: LibrarySearchParams) extends LibraryServiceMessage
42	case class Suggest(criteria: LibrarySearchParams) extends LibraryServiceMessage
43	case class PopulateSuggest(field: String, text: String) extends LibraryServiceMessage
44
45	def props(libraryServiceConstructor: UserInfo => LibraryService, userInfo: UserInfo): Props = {
46	Props(libraryServiceConstructor(userInfo))	1✔
47	}
48
49	def constructor(app: Application)(userInfo: UserInfo)(implicit executionContext: ExecutionContext) =
50	new LibraryService(userInfo, app.rawlsDAO, app.samDAO, app.searchDAO, app.ontologyDAO, app.consentDAO)	1✔
51	}
52
53
54	class LibraryService (protected val argUserInfo: UserInfo,
55	val rawlsDAO: RawlsDAO,
56	val samDao: SamDAO,
57	val searchDAO: SearchDAO,
58	val ontologyDAO: OntologyDAO,
59	val consentDAO: ConsentDAO)
60	(implicit protected val executionContext: ExecutionContext) extends Actor
61	with LibraryServiceSupport with AttributeSupport with PermissionsSupport with SprayJsonSupport with LazyLogging with WorkspacePublishingSupport {
62
63	lazy val log = LoggerFactory.getLogger(getClass)	×
64
65	implicit val userToken = argUserInfo	1✔
66
67	// attributes come in as standard json so we can use json schema for validation. Thus,
68	// we need to use the plain-array deserialization.
69	implicit val impAttributeFormat: AttributeFormat = new AttributeFormat with PlainArrayAttributeListSerializer	1✔
70
71	override def receive = {	1✔
72	case UpdateLibraryMetadata(ns: String, name: String, attrsJsonString: String, validate: Boolean) => updateLibraryMetadata(ns, name, attrsJsonString, validate) pipeTo sender	1✔
73	case GetLibraryMetadata(ns: String, name: String) => getLibraryMetadata(ns, name) pipeTo sender	1✔
74	case UpdateDiscoverableByGroups(ns: String, name: String, newGroups: Seq[String]) => updateDiscoverableByGroups(ns, name, newGroups) pipeTo sender	×
75	case GetDiscoverableByGroups(ns: String, name: String) => getDiscoverableByGroups(ns, name) pipeTo sender	1✔
76	case SetPublishAttribute(ns: String, name: String, value: Boolean) => setWorkspaceIsPublished(ns, name, value) pipeTo sender	1✔
77	case IndexAll => asAdmin {indexAll} pipeTo sender	×
78	case FindDocuments(criteria: LibrarySearchParams) => findDocuments(criteria) pipeTo sender	1✔
79	case Suggest(criteria: LibrarySearchParams) => suggest(criteria) pipeTo sender	1✔
80	case PopulateSuggest(field: String, text: String) => populateSuggest(field: String, text: String) pipeTo sender	1✔
81	}
82
83
84	def updateDiscoverableByGroups(ns: String, name: String, newGroups: Seq[String]): Future[PerRequestMessage] = {
85	if (newGroups.forall { g => FireCloudConfig.ElasticSearch.discoverGroupNames.contains(g) }) {	×
86	rawlsDAO.getWorkspace(ns, name) flatMap { workspaceResponse =>	×
87	// this is technically vulnerable to a race condition in which the workspace attributes have changed
88	// between the time we retrieved them and here, where we update them.
89	val remove = Seq(RemoveAttribute(discoverableWSAttribute))	×
90	val operations = newGroups map (group => AddListMember(discoverableWSAttribute, AttributeString(group)))	×
91	internalPatchWorkspaceAndRepublish(ns, name, remove ++ operations, isPublished(workspaceResponse)) map (RequestComplete(_))	×
92	}
93	} else {
94	Future(RequestCompleteWithErrorReport(BadRequest, s"groups must be subset of allowable groups: %s".format(FireCloudConfig.ElasticSearch.discoverGroupNames.toArray.mkString(", "))))	×
95	}
96	}
97
98	def getDiscoverableByGroups(ns: String, name: String): Future[PerRequestMessage] = {
99	rawlsDAO.getWorkspace(ns, name) map { workspaceResponse =>	1✔
100	val groups = workspaceResponse.workspace.attributes.get(discoverableWSAttribute) match {	1✔
101	case Some(vals:AttributeValueList) => vals.list.collect{	1✔
102	case s:AttributeString => s.value	1✔
103	}
104	case _ => List.empty[String]	1✔
105	}
106	RequestComplete(OK, groups.sortBy(_.toLowerCase))	1✔
107	}
108	}
109
110	private def isInvalid(attrsJsonString: String): (Boolean, Option[String]) = {
111	val validationResult = Try(schemaValidate(attrsJsonString))	1✔
112	validationResult match {
113	case Failure(ve: ValidationException) => (true, Some(getSchemaValidationMessages(ve).mkString("; ")))	1✔
114	case Failure(e) => (true, Some(e.getMessage))	×
115	case Success(x) => (false, None)	1✔
116	}
117	}
118
119	def updateLibraryMetadata(ns: String, name: String, attrsJsonString: String, validate: Boolean): Future[PerRequestMessage] = {
120	// we accept a string here, not a JsValue so we can most granularly handle json parsing
121
122	Try(attrsJsonString.parseJson.asJsObject.convertTo[AttributeMap]) match {	1✔
123	case Failure(ex:ParsingException) => Future(RequestCompleteWithErrorReport(BadRequest, "Invalid json supplied", ex))	×
124	case Failure(e) => Future(RequestCompleteWithErrorReport(BadRequest, BadRequest.defaultMessage, e))	×
125	case Success(attrs) =>
126	val userAttrs = attrs.get(AttributeName.withLibraryNS("dulvn")) match {	1✔
127	case Some(AttributeNull) \| None => attrs ++ Map(AttributeName.withLibraryNS("dulvn") -> AttributeNumber(FireCloudConfig.Duos.dulvn))	1✔
128	case _ => attrs
129	}
130	val (invalid, errorMessage): (Boolean, Option[String]) = isInvalid(attrsJsonString)	1✔
131	rawlsDAO.getWorkspace(ns, name) flatMap { workspaceResponse =>	1✔
132	val published = isPublished(workspaceResponse)	1✔
133	if (invalid && (published \|\| validate)) {	1✔
134	Future(RequestCompleteWithErrorReport(BadRequest, errorMessage.getOrElse(BadRequest.defaultMessage)))	1✔
135	} else {	1✔
136	// because not all editors can update discoverableByGroups, if the request does not include discoverableByGroups
137	// or if it is not being changed, don't include it in the update operations (less restrictive permissions will
138	// be checked by rawls)
139	val modDiscoverability = userAttrs.contains(discoverableWSAttribute) && isDiscoverableDifferent(workspaceResponse, userAttrs)	×
140	val skipAttributes =
141	if (modDiscoverability)
142	Seq(publishedFlag)	×
143	else
144	// if discoverable by groups is not being changed, then skip it (i.e. don't delete from ws)
145	Seq(publishedFlag, discoverableWSAttribute)	1✔
146
147	// this is technically vulnerable to a race condition in which the workspace attributes have changed
148	// between the time we retrieved them and here, where we update them.
149	val allOperations = generateAttributeOperations(workspaceResponse.workspace.attributes, userAttrs,	1✔
150	k => k.namespace == AttributeName.libraryNamespace && !skipAttributes.contains(k))	1✔
151	internalPatchWorkspaceAndRepublish(ns, name, allOperations, published) map (RequestComplete(_))	1✔
152	}
153	}
154	}
155	}
156
157	def getLibraryMetadata(ns: String, name: String): Future[PerRequestMessage] = {
158	rawlsDAO.getWorkspace(ns, name) flatMap { workspaceResponse =>	1✔
159	val allAttrs = workspaceResponse.workspace.attributes	1✔
160	val libAttrs = allAttrs.filter {	1✔
161	case ((LibraryService.publishedFlag,v)) => false	1✔
162	case ((k,v)) if k.namespace == AttributeName.libraryNamespace => true	1✔
163	case _ => false	1✔
164	}
165	Future(RequestComplete(OK, libAttrs))	1✔
166	}
167	}
168
169	/*
170	* Will republish if it is currently in the published state.
171	*/
172	private def internalPatchWorkspaceAndRepublish(ns: String, name: String, allOperations: Seq[AttributeUpdateOperation], isPublished: Boolean): Future[Workspace] = {
173	rawlsDAO.updateLibraryAttributes(ns, name, allOperations) map { newws =>	1✔
174	republishDocument(newws, ontologyDAO, searchDAO, consentDAO)	1✔
175	newws
176	}
177	}
178
179	// should only be used to change published state
180	def setWorkspaceIsPublished(ns: String, name: String, publishArg: Boolean): Future[PerRequestMessage] = {
181	rawlsDAO.getWorkspace(ns, name) flatMap { workspaceResponse =>	1✔
182	val currentPublished = isPublished(workspaceResponse)	1✔
183	// only need to validate metadata if we are actually publishing
184	val (invalid, errorMessage) = if (publishArg && !currentPublished)	1✔
185	isInvalid(workspaceResponse.workspace.attributes.toJson.compactPrint)
186	else
187	(false, None)
188
189	if (currentPublished == publishArg)	1✔
190	// user request would result in no change; just return as noop.
191	Future(RequestComplete(NoContent))	1✔
192	else if (invalid)	1✔
193	// user requested a publish, but metadata is invalid; return error.
194	Future(RequestCompleteWithErrorReport(BadRequest, errorMessage.getOrElse(BadRequest.defaultMessage)))	1✔
195	else {
196	// user requested a change in published flag, and metadata is valid; make the change.
197	setWorkspacePublishedStatus(workspaceResponse.workspace, publishArg, rawlsDAO, ontologyDAO, searchDAO, consentDAO) map { ws =>	1✔
198	RequestComplete(ws)	1✔
199	}
200	}
201	}
202	}
203
204	def indexAll: Future[PerRequestMessage] = {
205	logger.info("reindex: requesting workspaces from rawls ...")
206	rawlsDAO.getAllLibraryPublishedWorkspaces flatMap { workspaces: Seq[Workspace] =>	×
207	if (workspaces.isEmpty)	×
208	Future(RequestComplete(NoContent))	×
209	else {	×
210	logger.info("reindex: requesting ontology parents for workspaces ...")
211	val toIndex: Future[Seq[Document]] = indexableDocuments(workspaces, ontologyDAO, consentDAO)	×
212	toIndex map { documents =>	×
213	logger.info("reindex: resetting index ...")
214	searchDAO.recreateIndex()	×
215	logger.info("reindex: indexing datasets ...")
216	val indexedDocuments = searchDAO.bulkIndex(documents)	×
217	logger.info("reindex: ... done.")
218	if (indexedDocuments.hasFailures) {	×
219	RequestComplete(InternalServerError, indexedDocuments)	×
220	} else {
221	RequestComplete(OK, indexedDocuments)	×
222	}
223	}
224	}
225	}
226	}
227
228	def findDocuments(criteria: LibrarySearchParams): Future[PerRequestMessage] = {
229	getEffectiveDiscoverGroups(rawlsDAO) flatMap { userGroups =>	1✔
230	// we want docsFuture and ids to be parallelized - so declare them here, outside
231	// of the for-yield.
232	val docsFuture = searchDAO.findDocuments(criteria, userGroups)	1✔
233	val idsFuture = rawlsDAO.getWorkspaces	1✔
234
235	(for {
236	docs <- docsFuture	1✔
237	ids <- idsFuture	1✔
238	} yield RequestComplete(updateAccess(docs, ids))) recover {	1✔
239	case ex =>
240	throw new FireCloudExceptionWithErrorReport(ErrorReport(errorMessageFromSearchException(ex)))	×
241	}
242	}
243	}
244
245	def suggest(criteria: LibrarySearchParams): Future[PerRequestMessage] = {
246	getEffectiveDiscoverGroups(rawlsDAO) map {userGroups =>	1✔
247	searchDAO.suggestionsFromAll(criteria, userGroups)} map (RequestComplete(_))	1✔
248	}
249
250	def populateSuggest(field: String, text: String): Future[PerRequestMessage] = {
251	searchDAO.suggestionsForFieldPopulate(field, text) map {RequestComplete(_)} recoverWith {	1✔
252	case e: FireCloudException => Future(RequestCompleteWithErrorReport(BadRequest, s"suggestions not available for field %s".format(field)))	×
253	}
254	}
255
256	private def errorMessageFromSearchException(ex: Throwable): String = {
257	// elasticsearch errors are often nested, try to dig into them safely to find a message
258	val message = if (ex.getCause != null) {	×
259	val firstCause = ex.getCause	×
260	if (firstCause.getCause != null) {	×
261	firstCause.getCause.getMessage	×
262	} else {
263	firstCause.getMessage	×
264	}
265	} else {
266	ex.getMessage	×
267	}
268
269	Option(message) match {	×
270	case Some(m:String) => m
271	case _ => "Unknown error during search."	×
272	}
273
274	}
275
276	}

broadinstitute / firecloud-orchestration / 4798

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous