PFDR-252 v2 deposit scenario

.travis.yml

@@ -5,6 +5,9 @@ rvm:
   - 2.5
   - 2.6
 
+env:
+  - RACK_ENV=test RAILS_ENV=test
+
 branches:
   only:
     - master
@@ -17,6 +20,7 @@ before_install:
 before_script:
   - bundle exec rake checkpoint:migrate
   - bundle exec rake keycard:migrate
+  - bin/rails db:migrate
 
 script:
     - bundle exec rspec

app/attributes/deposit_status_type.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+class DepositStatusType < ActiveRecord::Type::Value
+  def cast(value)
+    super(value.to_s)
+  end
+
+  def deserialize(value)
+    Chipmunk::DepositStatus.new(value)
+  end
+
+  def serialize(deposit_status)
+    deposit_status.to_s
+  end
+
+end

app/controllers/v2/artifacts_controller.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module V2
+  class ArtifactsController < ResourceController
+
+    collection_policy ArtifactsPolicy
+
+    def self.of_any_type
+      AnyArtifact.new
+    end
+
+    def show
+      @artifact = Artifact.find(params[:id])
+      render json: @artifact, status: 200
+    end
+
+    def create
+      collection_policy.new(current_user).authorize! :new?
+      # We don't explicitly check for :save? permissions
+
+      if (duplicate = Artifact.find_by(id: params[:id]))
+        resource_policy.new(current_user, duplicate).authorize! :show?
+        head 303, location: v2_artifact_path(duplicate)
+      else
+        @artifact = new_artifact(params)
+        if @artifact.valid?
+          @artifact.save!
+          render json: @artifact, status: 201, location: v2_artifact_path(@artifact)
+        else
+          render json: @artifact.errors, status: :unprocessable_entity
+        end
+      end
+    end
+
+    private
+
+    def new_artifact(params)
+      Artifact.new(
+        id: params[:id],
+        user: current_user,
+        storage_format: params[:storage_format],
+        content_type: params[:content_type]
+      )
+    end
+
+  end
+end

app/controllers/v2/deposits_controller.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module V2
+  class DepositsController < ResourceController
+
+    def create
+      # TODO policy check
+      @deposit = Deposit.create!(
+        artifact: Artifact.find(params[:artifact_id]),
+        user: current_user,
+        status: :started
+      )
+      # TODO: don't pick a specific template
+      render "v2/deposits/show", status: 201, location: v2_deposit_path(@deposit)
+    end
+
+    def ready
+      # TODO policy check
+      @deposit = Deposit.find(params[:id])
+      case @deposit.status
+      when Deposit.statuses[:started]
+        @deposit.update!(status: Deposit.statuses[:ingesting])
+        FinishDepositJob.perform_later(@deposit)
+        render json: @deposit, status: 200
+      when Deposit.statuses[:ingesting]
+        render json: @deposit, status: 200
+      else # :completed, :failed, :cancelled
+        head 422 # TODO think about this response
+      end
+    end
+
+  end
+end

app/controllers/v2/revisions_controller.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module V2
+  class RevisionsController < ResourceController
+
+  end
+end

app/jobs/bag_move_job.rb

@@ -30,28 +30,28 @@ def ingest!
   end
 
   def validate
-    package.valid_for_ingest?(errors)
+    result = Services.validation.validate(package)
+    errors.concat result.errors
+    result.valid?
   end
 
   def move_bag
     source = incoming_storage.for(package)
-    package_storage.write(package, source)
+    package_storage.write(package, source) do |volume, storage_path|
+      package.storage_volume = volume.name
+      package.storage_path = storage_path
+    end
   end
 
   def record_success
     queue_item.transaction do
-      queue_item.status = :done
-      queue_item.save!
+      queue_item.success!
       package.save!
     end
   end
 
   def record_failure
-    queue_item.transaction do
-      queue_item.error = errors.join("\n\n")
-      queue_item.status = :failed
-      queue_item.save!
-    end
+    queue_item.fail!(errors)
   end
 
   def log_exception(exception)

app/jobs/finish_deposit_job.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+class FinishDepositJob < ApplicationJob
+  def perform(deposit)
+    Chipmunk::FinishDeposit.new(deposit).run
+  end
+end

app/models/artifact.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+class Artifact < ApplicationRecord
+
+  class AnyArtifact
+    def to_resources
+      Artifact.content_types.map {|t| Checkpoint::Resource::AllOfType.new(t) }
+    end
+
+    def resource_type
+      "Artifact"
+    end
+
+    def resource_id
+      Checkpoint::Resource::ALL
+    end
+  end
+
+  def self.resource_types
+    content_types
+  end
+
+  def self.content_types
+    Rails.application.config.validation["bagger_profile"].keys +
+      Rails.application.config.validation["external"].keys
+  end
+
+  def self.of_any_type
+    AnyArtifact.new
+  end
+
+  alias_method :identifier, :id
+
+  # Each artifact belongs to a single user
+  belongs_to :user
+  # Deposits are collections of zero or more revisions
+  has_many :revisions
+  # Revisions are added to artifacts via deposits
+  has_many :deposits
+
+  validates :id, presence: true,
+    format: { with:    Services.uuid_format,
+              message: "must be a valid v4 uuid." }
+
+  validates :user, presence: true
+  validates :storage_format, presence: true # TODO this is a controlled vocabulary
+  validates :content_type, presence: true # TODO this is a controlled vocabulary
+
+  def stored?
+    revisions.any?
+  end
+
+end

app/models/deposit.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+class Deposit < ApplicationRecord
+
+  # Each deposit is created by a single user
+  belongs_to :user
+  # A deposit is an attempt to append a revision to a single artifact
+  belongs_to :artifact
+
+  # TODO Could not get the attributes api to work with a custom type
+  enum status: {
+    started:   "started",
+    canceled:  "cancelled",
+    ingesting: "ingesting",
+    failed:    "failed",
+    completed: "completed"
+  }
+
+  validates :user, presence: true
+  validates :artifact, presence: true
+  validates :status, presence: true # TODO this is a controlled vocabulary
+
+  def identifier
+    id.to_s
+  end
+
+  def username
+    user.username
+  end
+
+  def content_type
+    artifact.content_type
+  end
+
+  def storage_format
+    artifact.storage_format
+  end
+
+  def complete!
+    update!(status: "completed")
+  end
+
+  def fail!(errors)
+    update!(status: "failed", error: errors.join("\n"))
+  end
+
+  def upload_link
+    Services.incoming_storage.upload_link(self)
+  end
+
+end

app/models/package.rb

@@ -14,17 +14,29 @@ class Package < ApplicationRecord
   def to_param
     bag_id
   end
+  alias_method :identifier, :to_param
 
   validates :bag_id, presence: true, length: { minimum: 6 }
   validates :user_id, presence: true
   validates :external_id, presence: true
-  validates :format, presence: true
+  validates :format, presence: true, format: /bag/
 
   # Declare the policy class to use for authz
   def self.policy_class
     PackagePolicy
   end
 
+  # Rails overrides the format param on requests, so we rename this to storage_format.
+  # This alias is for backwards compatibility
+  # alias_method :storage_format, :format
+  def storage_format
+    format
+  end
+
+  def username
+    user.username
+  end
+
   def upload_link
     Services.incoming_storage.upload_link(self)
   end
@@ -40,39 +52,6 @@ def storage_location
     storage_path
   end
 
-  def storage_location=
-    raise "storage_location is not writable; use storage_volume and storage_path"
-  end
-
-  # TODO: This is nasty... but the storage factory checks that the package is stored,
-  # so we have to make the storage proxy manually here. Once the ingest and preservation
-  # responsibilities are clarified, this will fall out. See PFDR-184.
-  def valid_for_ingest?(errors = [])
-    if stored?
-      errors << "Package #{bag_id} is already stored"
-    elsif format != Chipmunk::Bag.format
-      errors << "Package #{bag_id} has invalid format: #{format}"
-    elsif !incoming_storage.include?(self)
-      errors << "Bag #{bag_id} does not exist in incoming storage."
-    end
-
-    return false unless errors.empty?
-
-    Chipmunk::Bag::Validator.new(self, errors, incoming_storage.for(self)).valid?
-  end
-
-  def external_validation_cmd
-    ext_cmd = Rails.application.config.validation["external"][content_type.to_s]
-    return unless ext_cmd
-
-    path = incoming_storage.for(self).path
-    [ext_cmd, external_id, path].join(" ")
-  end
-
-  def bagger_profile
-    Rails.application.config.validation["bagger_profile"][content_type.to_s]
-  end
-
   def resource_type
     content_type
   end

app/models/queue_item.rb

@@ -19,6 +19,14 @@ def user
     package.user
   end
 
+  def success!
+    update!(status: :done)
+  end
+
+  def fail!(errors)
+    update!(status: :failed, error: errors.join("\n\n"))
+  end
+
   scope :for_package, ->(package_id) { where(package_id: package_id) unless package_id.blank? }
   scope :for_packages, ->(package_scope) { joins(:package).merge(package_scope) }
 end

app/models/revision.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+class Revision < ApplicationRecord
+  belongs_to :artifact
+  belongs_to :deposit
+end

app/policies/artifacts_policy.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+class ArtifactsPolicy < CollectionPolicy
+  def index?
+    can?(:show, Artifact.of_any_type)
+  end
+
+  def new?
+    can?(:save, Artifact.of_any_type)
+  end
+
+  def base_scope
+    Artifact.all
+  end
+
+  def resolve
+    # Via the role map resolver, a user has access to:
+    #   * All artifacts, if the user is an administrator
+    #   * Artifacts of content types for which the user is a content manager
+    #   * Artifacts of content types for which the user is authorized viewer
+    #   * Any specific artifacts for which the user is granted access
+    ViewableResources.for(user, scope)
+  end
+end