Merge branch '13345-conan-file-metadatum' into 'master'

Conan snapshot and manifest API endpoints

See merge request gitlab-org/gitlab!16418

db/migrate/20190910211526_create_packages_conan_file_metadata.rb

+# frozen_string_literal: true
+
+class CreatePackagesConanFileMetadata < ActiveRecord::Migration[5.2]
+  include Gitlab::Database::MigrationHelpers
+
+  DOWNTIME = false
+
+  def change
+    create_table :packages_conan_file_metadata do |t|
+      t.references :package_file, index: { unique: true }, null: false, foreign_key: { to_table: :packages_package_files, on_delete: :cascade }, type: :bigint
+      t.timestamps_with_timezone
+      t.string "recipe_revision", null: false, default: "0", limit: 255
+      t.string "package_revision", limit: 255
+      t.string "conan_package_reference", limit: 255
+      t.integer "conan_file_type", limit: 2, null: false
+    end
+  end
+end

db/migrate/20191029125305_create_packages_conan_metadata.rb

+# frozen_string_literal: true
+
+class CreatePackagesConanMetadata < ActiveRecord::Migration[5.2]
+  include Gitlab::Database::MigrationHelpers
+
+  DOWNTIME = false
+
+  def change
+    create_table :packages_conan_metadata do |t|
+      t.references :package, index: { unique: true }, null: false, foreign_key: { to_table: :packages_packages, on_delete: :cascade }, type: :bigint
+      t.timestamps_with_timezone
+      t.string "package_username", null: false, limit: 255
+      t.string "package_channel", null: false, limit: 255
+    end
+  end
+end

db/schema.rb

@@ -2653,6 +2653,26 @@ ActiveRecord::Schema.define(version: 2019_10_29_191901) do
     t.index ["project_id", "token_encrypted"], name: "index_feature_flags_clients_on_project_id_and_token_encrypted", unique: true
   end
 
+  create_table "packages_conan_file_metadata", force: :cascade do |t|
+    t.bigint "package_file_id", null: false
+    t.datetime_with_timezone "created_at", null: false
+    t.datetime_with_timezone "updated_at", null: false
+    t.string "recipe_revision", limit: 255, default: "0", null: false
+    t.string "package_revision", limit: 255
+    t.string "conan_package_reference", limit: 255
+    t.integer "conan_file_type", limit: 2, null: false
+    t.index ["package_file_id"], name: "index_packages_conan_file_metadata_on_package_file_id", unique: true
+  end
+
+  create_table "packages_conan_metadata", force: :cascade do |t|
+    t.bigint "package_id", null: false
+    t.datetime_with_timezone "created_at", null: false
+    t.datetime_with_timezone "updated_at", null: false
+    t.string "package_username", limit: 255, null: false
+    t.string "package_channel", limit: 255, null: false
+    t.index ["package_id"], name: "index_packages_conan_metadata_on_package_id", unique: true
+  end
+
   create_table "packages_maven_metadata", force: :cascade do |t|
     t.bigint "package_id", null: false
     t.datetime_with_timezone "created_at", null: false
@@ -4326,6 +4346,8 @@ ActiveRecord::Schema.define(version: 2019_10_29_191901) do
   add_foreign_key "operations_feature_flag_scopes", "operations_feature_flags", column: "feature_flag_id", on_delete: :cascade
   add_foreign_key "operations_feature_flags", "projects", on_delete: :cascade
   add_foreign_key "operations_feature_flags_clients", "projects", on_delete: :cascade
+  add_foreign_key "packages_conan_file_metadata", "packages_package_files", column: "package_file_id", on_delete: :cascade
+  add_foreign_key "packages_conan_metadata", "packages_packages", column: "package_id", on_delete: :cascade
   add_foreign_key "packages_maven_metadata", "packages_packages", column: "package_id", name: "fk_be88aed360", on_delete: :cascade
   add_foreign_key "packages_package_files", "packages_packages", column: "package_id", name: "fk_86f0f182f8", on_delete: :cascade
   add_foreign_key "packages_package_metadata", "packages_packages", column: "package_id", on_delete: :cascade

ee/app/finders/packages/conan_package_finder.rb

@@ -2,15 +2,15 @@
 
 module Packages
   class ConanPackageFinder
-    attr_reader :query, :current_user
+    attr_reader :current_user, :query
 
-    def initialize(query, current_user)
-      @query = query
+    def initialize(current_user, params)
       @current_user = current_user
+      @query = params[:query]
     end
 
     def execute
-      packages_for_current_user.with_name_like(query).order_name_asc
+      packages_for_current_user.with_name_like(query).order_name_asc if query
     end
 
     private

ee/app/models/packages/conan_file_metadatum.rb

+# frozen_string_literal: true
+
+class Packages::ConanFileMetadatum < ApplicationRecord
+  belongs_to :package_file, inverse_of: :conan_file_metadatum
+
+  validates :package_file, presence: true
+
+  validates :recipe_revision,
+    presence: true,
+    format: { with: Gitlab::Regex.conan_revision_regex }
+
+  validates :package_revision, absence: true, if: :recipe_file?
+  validates :package_revision, format: { with: Gitlab::Regex.conan_revision_regex }, if: :package_file?
+
+  validates :conan_package_reference, absence: true, if: :recipe_file?
+  validates :conan_package_reference, format: { with: Gitlab::Regex.conan_package_reference_regex }, if: :package_file?
+
+  enum conan_file_type: { recipe_file: 1, package_file: 2 }
+
+  RECIPE_FILES = %w[conanfile.py conanmanifest.txt].freeze
+  PACKAGE_FILES = %w[conaninfo.txt conanmanifest.txt conan_package.tgz].freeze
+end

ee/app/models/packages/conan_metadatum.rb

+# frozen_string_literal: true
+
+class Packages::ConanMetadatum < ApplicationRecord
+  belongs_to :package, inverse_of: :conan_metadatum
+
+  validates :package, presence: true
+
+  validates :package_username,
+    presence: true,
+    format: { with: Gitlab::Regex.conan_recipe_component_regex }
+
+  validates :package_channel,
+    presence: true,
+    format: { with: Gitlab::Regex.conan_recipe_component_regex }
+
+  def recipe
+    "#{package.name}/#{package.version}@#{package_username}/#{package_channel}"
+  end
+
+  def recipe_path
+    recipe.tr('@', '/')
+  end
+
+  def self.package_username_from(full_path:)
+    full_path.tr('/', '+')
+  end
+
+  def self.full_path_from(package_username:)
+    package_username.tr('+', '/')
+  end
+end

ee/app/models/packages/package.rb

@@ -5,10 +5,14 @@ class Packages::Package < ApplicationRecord
   belongs_to :project
   # package_files must be destroyed by ruby code in order to properly remove carrierwave uploads and update project statistics
   has_many :package_files, dependent: :destroy # rubocop:disable Cop/ActiveRecordDependent
+  has_one :conan_metadatum, inverse_of: :package
   has_one :maven_metadatum, inverse_of: :package
 
+  accepts_nested_attributes_for :conan_metadatum
   accepts_nested_attributes_for :maven_metadatum
 
+  delegate :recipe, :recipe_path, to: :conan_metadatum, prefix: :conan
+
   validates :project, presence: true
 
   validates :name,

ee/app/models/packages/package_file.rb

@@ -8,12 +8,17 @@ class Packages::PackageFile < ApplicationRecord
 
   belongs_to :package
 
+  has_one :conan_file_metadatum, inverse_of: :package_file
+
+  accepts_nested_attributes_for :conan_file_metadatum
+
   validates :package, presence: true
   validates :file, presence: true
   validates :file_name, presence: true
 
   scope :recent, -> { order(id: :desc) }
   scope :with_files_stored_locally, -> { where(file_store: ::Packages::PackageFileUploader::Store::LOCAL) }
+  scope :with_conan_file_metadata, -> { includes(:conan_file_metadatum) }
 
   mount_uploader :file, Packages::PackageFileUploader
 

ee/app/presenters/conan_package_presenter.rb

+# frozen_string_literal: true
+
+class ConanPackagePresenter
+  include API::Helpers::RelatedResourcesHelpers
+  include Gitlab::Utils::StrongMemoize
+
+  def initialize(recipe, user, project)
+    @recipe = recipe
+    @user = user
+    @project = project
+  end
+
+  def recipe_urls
+    map_package_files do |package_file|
+      build_recipe_file_url(package_file) if package_file.conan_file_metadatum.recipe_file?
+    end
+  end
+
+  def recipe_snapshot
+    map_package_files do |package_file|
+      package_file.file_md5 if package_file.conan_file_metadatum.recipe_file?
+    end
+  end
+
+  def package_urls
+    map_package_files do |package_file|
+      build_package_file_url(package_file) if package_file.conan_file_metadatum.package_file?
+    end
+  end
+
+  def package_snapshot
+    map_package_files do |package_file|
+      package_file.file_md5 if package_file.conan_file_metadatum.package_file?
+    end
+  end
+
+  private
+
+  def build_recipe_file_url(package_file)
+    expose_url(
+      api_v4_packages_conan_v1_files_export_path(
+        package_name: package.name,
+        package_version: package.version,
+        package_username: package.conan_metadatum.package_username,
+        package_channel: package.conan_metadatum.package_channel,
+        recipe_revision: package_file.conan_file_metadatum.recipe_revision,
+        file_name: package_file.file_name
+      )
+    )
+  end
+
+  def build_package_file_url(package_file)
+    expose_url(
+      api_v4_packages_conan_v1_files_package_path(
+        package_name: package.name,
+        package_version: package.version,
+        package_username: package.conan_metadatum.package_username,
+        package_channel: package.conan_metadatum.package_channel,
+        recipe_revision: package_file.conan_file_metadatum.recipe_revision,
+        conan_package_reference: package_file.conan_file_metadatum.conan_package_reference,
+        package_revision: package_file.conan_file_metadatum.package_revision,
+        file_name: package_file.file_name
+      )
+    )
+  end
+
+  def map_package_files
+    package_files.to_a.map do |package_file|
+      [package_file.file_name, yield(package_file)]
+    end.to_h.compact
+  end
+
+  def package_files
+    return unless package
+
+    @package_files ||= package.package_files.with_conan_file_metadata
+  end
+
+  def package
+    strong_memoize(:package) do
+      name, version = @recipe.split('@')[0].split('/')
+
+      @project.packages.with_name(name).with_version(version).order_created.last
+    end
+  end
+end

ee/app/services/packages/conan/search_service.rb

@@ -23,6 +23,8 @@ module Packages
       def search_results
         return [] if wildcard_query?
 
+        return search_for_single_package(sanitized_query) if params[:query].include?(RECIPE_SEPARATOR)
+
         search_packages(build_query)
       end
 
@@ -31,11 +33,9 @@ module Packages
       end
 
       def build_query
-        sanitized_query = sanitize_sql_like(params[:query].delete(WILDCARD))
         return "#{sanitized_query}%" if params[:query].end_with?(WILDCARD)
-        return sanitized_query if sanitized_query.include?(RECIPE_SEPARATOR)
 
-        "#{sanitized_query}/%"
+        sanitized_query
       end
 
       def feature_available?
@@ -43,7 +43,21 @@ module Packages
       end
 
       def search_packages(query)
-        Packages::ConanPackageFinder.new(query, current_user).execute.pluck_names
+        Packages::ConanPackageFinder.new(current_user, query: query).execute.map(&:conan_recipe)
+      end
+
+      def search_for_single_package(query)
+        name, version, username, _ = query.split(/[@\/]/)
+        full_path = Packages::ConanMetadatum.full_path_from(package_username: username)
+        project = Project.find_by_full_path(full_path)
+        return unless current_user.can?(:read_package, project)
+
+        result = project.packages.with_name(name).with_version(version).order_created.last
+        [result&.conan_recipe].compact
+      end
+
+      def sanitized_query
+        @sanitized_query ||= sanitize_sql_like(params[:query].delete(WILDCARD))
       end
     end
   end

ee/lib/api/conan_packages.rb

@@ -4,36 +4,29 @@ module API
   class ConanPackages < Grape::API
     helpers ::API::Helpers::PackagesHelpers
 
+    PACKAGE_REQUIREMENTS = {
+      package_name: API::NO_SLASH_URL_PART_REGEX,
+      package_version: API::NO_SLASH_URL_PART_REGEX,
+      package_username: API::NO_SLASH_URL_PART_REGEX,
+      package_channel: API::NO_SLASH_URL_PART_REGEX
+    }.freeze
+
+    FILE_NAME_REQUIREMENTS = {
+      file_name: Gitlab::Regex.conan_file_name_regex
+    }.freeze
+
+    PACKAGE_COMPONENT_REGEX = Gitlab::Regex.conan_recipe_component_regex
+
     before do
       not_found! unless Feature.enabled?(:conan_package_registry)
       require_packages_enabled!
 
       # Personal access token will be extracted from Bearer or Basic authorization
-      # in the overriden find_personal_access_token helper
+      # in the overridden find_personal_access_token helper
       authenticate!
     end
 
-    namespace 'packages/conan/v1/users/' do
-      format :txt
-
-      desc 'Authenticate user against conan CLI' do
-        detail 'This feature was introduced in GitLab 12.2'
-      end
-      get 'authenticate' do
-        token = ::Gitlab::ConanToken.from_personal_access_token(access_token)
-        token.to_jwt
-      end
-
-      desc 'Check for valid user credentials per conan CLI' do
-        detail 'This feature was introduced in GitLab 12.3'
-      end
-      get 'check_credentials' do
-        authenticate!
-        :ok
-      end
-    end
-
-    namespace 'packages/conan/v1/' do
+    namespace 'packages/conan/v1' do
       desc 'Ping the Conan API' do
         detail 'This feature was introduced in GitLab 12.2'
       end
@@ -42,7 +35,7 @@ module API
       end
 
       desc 'Search for packages' do
-        detail 'This feature was introduced in GitLab 12.3'
+        detail 'This feature was introduced in GitLab 12.4'
       end
       params do
         requires :q, type: String, desc: 'Search query'
@@ -51,91 +44,220 @@ module API
         service = ::Packages::Conan::SearchService.new(current_user, query: params[:q]).execute
         service.payload
       end
-    end
 
-    namespace 'packages/conan/v1/conans/*url_recipe' do
-      before do
-        render_api_error!("Invalid recipe", 400) unless valid_url_recipe?(params[:url_recipe])
+      namespace 'users' do
+        format :txt
+
+        desc 'Authenticate user against conan CLI' do
+          detail 'This feature was introduced in GitLab 12.2'
+        end
+        get 'authenticate' do
+          token = ::Gitlab::ConanToken.from_personal_access_token(access_token)
+          token.to_jwt
+        end
+
+        desc 'Check for valid user credentials per conan CLI' do
+          detail 'This feature was introduced in GitLab 12.4'
+        end
+        get 'check_credentials' do
+          authenticate!
+          :ok
+        end
       end
+
       params do
-        requires :url_recipe, type: String, desc: 'Package recipe'
+        requires :package_name, type: String, regexp: PACKAGE_COMPONENT_REGEX, desc: 'Package name'
+        requires :package_version, type: String, regexp: PACKAGE_COMPONENT_REGEX, desc: 'Package version'
+        requires :package_username, type: String, regexp: PACKAGE_COMPONENT_REGEX, desc: 'Package username'
+        requires :package_channel, type: String, regexp: PACKAGE_COMPONENT_REGEX, desc: 'Package channel'
       end
+      namespace 'conans/:package_name/:package_version/:package_username/:package_channel', requirements: PACKAGE_REQUIREMENTS do
+        # Get the snapshot
+        #
+        # the snapshot is a hash of { filename: md5 hash }
+        # md5 hash is the has of that file. This hash is used to diff the files existing on the client
+        # to determine which client files need to be uploaded if no recipe exists the snapshot is empty
+        desc 'Package Snapshot' do
+          detail 'This feature was introduced in GitLab 12.5'
+        end
+        get 'packages/:conan_package_reference' do
+          authorize!(:read_package, project)
 
-      # Get the recipe manifest
-      # returns the download urls for the existing recipe in the registry
-      #
-      # the manifest is a hash of { filename: url }
-      # where the url is the download url for the file
-      desc 'Package Digest' do
-        detail 'This feature was introduced in GitLab 12.3'
-      end
-      get 'packages/:package_id/digest' do
-        render_api_error!("No recipe manifest found", 404)
-      end
+          presenter = ConanPackagePresenter.new(recipe, current_user, project)
 
-      desc 'Recipe Digest' do
-        detail 'This feature was introduced in GitLab 12.3'
-      end
-      get 'digest' do
-        render_api_error!("No recipe manifest found", 404)
-      end
+          present presenter, with: EE::API::Entities::ConanPackage::ConanPackageSnapshot
+        end
+
+        desc 'Recipe Snapshot' do
+          detail 'This feature was introduced in GitLab 12.5'
+        end
+        get do
+          authorize!(:read_package, project)
+
+          presenter = ConanPackagePresenter.new(recipe, current_user, project)
+
+          present presenter, with: EE::API::Entities::ConanPackage::ConanRecipeSnapshot
+        end
+
+        # Get the manifest
+        # returns the download urls for the existing recipe in the registry
+        #
+        # the manifest is a hash of { filename: url }
+        # where the url is the download url for the file
+        desc 'Package Digest' do
+          detail 'This feature was introduced in GitLab 12.5'
+        end
+        get 'packages/:conan_package_reference/digest' do
+          authorize!(:read_package, project)
+
+          presenter = ConanPackagePresenter.new(recipe, current_user, project)
 
-      # Get the upload urls
-      #
-      # request body contains { filename: filesize } where the filename is the
-      # name of the file the conan client is requesting to upload
-      #
-      # returns { filename: url }
-      # where the url is the upload url for the file that the conan client will use
-      desc 'Package Upload Urls' do
-        detail 'This feature was introduced in GitLab 12.3'
+          render_api_error!("No recipe manifest found", 404) if presenter.package_urls.empty?
+
+          present presenter, with: EE::API::Entities::ConanPackage::ConanPackageManifest
+        end
+
+        desc 'Recipe Digest' do
+          detail 'This feature was introduced in GitLab 12.5'
+        end
+        get 'digest' do
+          authorize!(:read_package, project)
+
+          presenter = ConanPackagePresenter.new(recipe, current_user, project)
+
+          render_api_error!("No recipe manifest found", 404) if presenter.recipe_urls.empty?
+
+          present presenter, with: EE::API::Entities::ConanPackage::ConanRecipeManifest
+        end
+
+        # Get the upload urls
+        #
+        # request body contains { filename: filesize } where the filename is the
+        # name of the file the conan client is requesting to upload
+        #
+        # returns { filename: url }
+        # where the url is the upload url for the file that the conan client will use
+        desc 'Package Upload Urls' do
+          detail 'This feature was introduced in GitLab 12.4'
+        end
+        params do
+          requires :conan_package_reference, type: String, desc: 'Conan package ID'
+        end
+        post 'packages/:conan_package_reference/upload_urls' do
+          authorize!(:read_package, project)
+
+          status 200
+          upload_urls = package_upload_urls(::Packages::ConanFileMetadatum::PACKAGE_FILES)
+
+          present upload_urls, with: EE::API::Entities::ConanPackage::ConanUploadUrls
+        end
+
+        desc 'Recipe Upload Urls' do
+          detail 'This feature was introduced in GitLab 12.4'
+        end
+        post 'upload_urls' do
+          authorize!(:read_package, project)
+
+          status 200
+          upload_urls = recipe_upload_urls(::Packages::ConanFileMetadatum::RECIPE_FILES)
+
+          present upload_urls, with: EE::API::Entities::ConanPackage::ConanUploadUrls
+        end
       end
+
       params do
-        requires :package_id, type: String, desc: 'Conan package ID'
-      end
-      post 'packages/:package_id/upload_urls' do
-        status 200
-        {
-          'conaninfo.txt':      "#{base_file_url}/#{params[:url_recipe]}/-/0/package/#{params[:package_id]}/0/conaninfo.txt",
-          'conanmanifest.txt': "#{base_file_url}/#{params[:url_recipe]}/-/0/package/#{params[:package_id]}/0/conanmanifest.txt",
-          'conan_package.tgz': "#{base_file_url}/#{params[:url_recipe]}/-/0/package/#{params[:package_id]}/0/conan_package.tgz"
-        }
+        requires :package_name, type: String, regexp: PACKAGE_COMPONENT_REGEX, desc: 'Package name'
+        requires :package_version, type: String, regexp: PACKAGE_COMPONENT_REGEX, desc: 'Package version'
+        requires :package_username, type: String, regexp: PACKAGE_COMPONENT_REGEX, desc: 'Package username'
+        requires :package_channel, type: String, regexp: PACKAGE_COMPONENT_REGEX, desc: 'Package channel'
+        requires :recipe_revision, type: String, desc: 'Conan Recipe Revision'
       end
+      namespace 'files/:package_name/:package_version/:package_username/:package_channel/:recipe_revision' do
+        before do
+          authenticate_non_get!
+        end
+
+        params do
+          requires :file_name, type: String, desc: 'Package file name'
+        end
+        desc 'Download recipe files' do
+          detail 'This feature was introduced in GitLab 12.5'
+        end
+        get 'export/:file_name' do
+          not_found!
+        end
 
-      desc 'Recipe Upload Urls' do
-        detail 'This feature was introduced in GitLab 12.3'
+        params do
+          requires :conan_package_reference, type: String, desc: 'Conan Package ID'
+          requires :package_revision, type: String, desc: 'Conan Package Revision'
+          requires :file_name, type: String, desc: 'Package file name'
+        end
+        desc 'Download package files' do
+          detail 'This feature was introduced in GitLab 12.5'
+        end
+        get 'package/:conan_package_reference/:package_revision/:file_name' do
+          not_found!
+        end
       end
-      post 'upload_urls' do
-        status 200
-        {
-          'conanfile.py':      "#{base_file_url}/#{params[:url_recipe]}/-/0/export/conanfile.py",
-          'conanmanifest.txt': "#{base_file_url}/#{params[:url_recipe]}/-/0/export/conanmanifest.txt"
-        }
+    end
+
+    helpers do
+      include Gitlab::Utils::StrongMemoize
+      include ::API::Helpers::RelatedResourcesHelpers
+
+      def recipe_upload_urls(file_names)
+        { upload_urls: Hash[
+          file_names.collect do |file_name|
+            [file_name, recipe_file_upload_url(file_name)]
+          end
+        ] }
       end
 
-      # Get the recipe snapshot
-      #
-      # the snapshot is a hash of { filename: md5 hash }
-      # md5 hash is the has of that file. This hash is used to diff the files existing on the client
-      # to determine which client files need to be uploaded if no recipe exists the snapshot is empty
-      desc 'Recipe Snapshot' do
-        detail 'This feature was introduced in GitLab 12.3'
+      def package_upload_urls(file_names)
+        { upload_urls: Hash[
+          file_names.collect do |file_name|
+            [file_name, package_file_upload_url(file_name)]
+          end
+        ] }
       end
-      get '/' do
-        {}
+
+      def package_file_upload_url(file_name)
+        expose_url(
+          api_v4_packages_conan_v1_files_package_path(
+            package_name: params[:package_name],
+            package_version: params[:package_version],
+            package_username: params[:package_username],
+            package_channel: params[:package_channel],
+            recipe_revision: '0',
+            conan_package_reference: params[:conan_package_reference],
+            package_revision: '0',
+            file_name: file_name
+          )
+        )
       end
 
-      desc 'Package Snapshot' do
-        detail 'This feature was introduced in GitLab 12.3'
+      def recipe_file_upload_url(file_name)
+        expose_url(
+          api_v4_packages_conan_v1_files_export_path(
+            package_name: params[:package_name],
+            package_version: params[:package_version],
+            package_username: params[:package_username],
+            package_channel: params[:package_channel],
+            recipe_revision: '0',
+            file_name: file_name
+          )
+        )
       end
-      get 'packages/:package_id' do
-        {}
+
+      def recipe
+        "%{package_name}/%{package_version}@%{package_username}/%{package_channel}" % params.symbolize_keys
       end
-    end
 
-    helpers do
-      def base_file_url
-        "#{::Settings.gitlab.base_url}/api/v4/packages/conan/v1/files"
+      def project
+        strong_memoize(:project) do
+          full_path = ::Packages::ConanMetadatum.full_path_from(package_username: params[:package_username])
+          Project.find_by_full_path(full_path)
+        end
       end
 
       def find_personal_access_token
@@ -167,10 +289,6 @@ module API
 
         PersonalAccessToken.find_by_token(token)
       end
-
-      def valid_url_recipe?(recipe_url)
-        recipe_url =~ %r{\A(([\w](\.|\+|-)?)*(\/?)){4}\z}
-      end
     end
   end
 end

ee/lib/ee/api/entities.rb

@@ -808,6 +808,28 @@ module EE
         end
       end
 
+      module ConanPackage
+        class ConanPackageManifest < Grape::Entity
+          expose :package_urls, merge: true
+        end
+
+        class ConanPackageSnapshot < Grape::Entity
+          expose :package_snapshot, merge: true
+        end
+
+        class ConanRecipeManifest < Grape::Entity
+          expose :recipe_urls, merge: true
+        end
+
+        class ConanRecipeSnapshot < Grape::Entity
+          expose :recipe_snapshot, merge: true
+        end
+
+        class ConanUploadUrls < Grape::Entity
+          expose :upload_urls, merge: true
+        end
+      end
+
       class NpmPackage < Grape::Entity
         expose :name
         expose :versions

ee/lib/ee/gitlab/regex.rb

@@ -6,6 +6,23 @@ module EE
       extend ActiveSupport::Concern
 
       class_methods do
+        def conan_file_name_regex
+          @conan_file_name_regex ||=
+            %r{\A#{(::Packages::ConanFileMetadatum::RECIPE_FILES + ::Packages::ConanFileMetadatum::PACKAGE_FILES).join("|")}\z}.freeze
+        end
+
+        def conan_package_reference_regex
+          @conan_package_reference_regex ||= %r{\A[A-Za-z0-9]+\z}.freeze
+        end
+
+        def conan_revision_regex
+          @conan_revision_regex ||= %r{\A0\z}.freeze
+        end
+
+        def conan_recipe_component_regex
+          @conan_recipe_component_regex ||= %r{\A(\w[.+-]?)+\z}.freeze
+        end
+
         def package_name_regex
           @package_name_regex ||= %r{\A\@?(([\w\-\.\+]*)\/)*([\w\-\.]+)@?(([\w\-\.\+]*)\/)*([\w\-\.]*)\z}.freeze
         end

ee/spec/factories/packages.rb

@@ -31,15 +31,98 @@ FactoryBot.define do
     end
 
     factory :conan_package do
-      sequence(:name) { |n| "package-#{n}/1.0.0@#{project.full_path.tr('/', '+')}/stable"}
+      conan_metadatum
+
+      after :build do |package|
+        package.conan_metadatum.package_username = Packages::ConanMetadatum.package_username_from(
+          full_path: package.project.full_path
+        )
+      end
+
+      sequence(:name) { |n| "package-#{n}" }
       version { '1.0.0' }
       package_type { 'conan' }
+
+      after :create do |package|
+        create :conan_package_file, :conan_recipe_file, package: package
+        create :conan_package_file, :conan_recipe_manifest, package: package
+        create :conan_package_file, :conan_package_info, package: package
+        create :conan_package_file, :conan_package_manifest, package: package
+        create :conan_package_file, :conan_package, package: package
+      end
     end
   end
 
   factory :package_file, class: Packages::PackageFile do
     package
 
+    factory :conan_package_file do
+      trait(:conan_recipe_file) do
+        after :create do |package_file|
+          create :conan_file_metadatum, :recipe_file, package_file: package_file
+        end
+
+        file { fixture_file_upload('ee/spec/fixtures/conan/recipe_conanfile.py') }
+        file_name { 'recipe_conanfile.py' }
+        file_sha1 { 'be93151dc23ac34a82752444556fe79b32c7a1ad' }
+        file_md5 { '12345abcde' }
+        file_type { 'py' }
+        size { 400.kilobytes }
+      end
+
+      trait(:conan_recipe_manifest) do
+        after :create do |package_file|
+          create :conan_file_metadatum, :recipe_file, package_file: package_file
+        end
+
+        file { fixture_file_upload('ee/spec/fixtures/conan/recipe_conanmanifest.txt') }
+        file_name { 'recipe_conanmanifest.txt' }
+        file_sha1 { 'be93151dc23ac34a82752444556fe79b32c7a1ad' }
+        file_md5 { '12345abcde' }
+        file_type { 'txt' }
+        size { 400.kilobytes }
+      end
+
+      trait(:conan_package_manifest) do
+        after :create do |package_file|
+          create :conan_file_metadatum, :package_file, package_file: package_file
+        end
+
+        file { fixture_file_upload('ee/spec/fixtures/conan/package_conanmanifest.txt') }
+        file_name { 'package_conanmanifest.txt' }
+        file_sha1 { 'be93151dc23ac34a82752444556fe79b32c7a1ad' }
+        file_md5 { '12345abcde' }
+        file_type { 'txt' }
+        size { 400.kilobytes }
+      end
+
+      trait(:conan_package_info) do
+        after :create do |package_file|
+          create :conan_file_metadatum, :package_file, package_file: package_file
+        end
+
+        file { fixture_file_upload('ee/spec/fixtures/conan/package_conaninfo.txt') }
+        file_name { 'package_conaninfo.txt' }
+        file_sha1 { 'be93151dc23ac34a82752444556fe79b32c7a1ad' }
+        file_md5 { '12345abcde' }
+        file_type { 'txt' }
+        size { 400.kilobytes }
+      end
+
+      trait(:conan_package) do
+        after :create do |package_file|
+          create :conan_file_metadatum, :package_file, package_file: package_file
+        end
+
+        file { fixture_file_upload('ee/spec/fixtures/conan/conan_package.tgz') }
+        file_name { 'conan_package.tgz' }
+        file_sha1 { 'be93151dc23ac34a82752444556fe79b32c7a1ad' }
+        file_md5 { '12345abcde' }
+        file_type { 'tgz' }
+        size { 400.kilobytes }
+      end
+    end
+
     trait(:jar) do
       file { fixture_file_upload('ee/spec/fixtures/maven/my-app-1.0-20180724.124855-1.jar') }
       file_name { 'my-app-1.0-20180724.124855-1.jar' }
@@ -84,4 +167,25 @@ FactoryBot.define do
     app_name { 'my-app' }
     app_version { '1.0-SNAPSHOT' }
   end
+
+  factory :conan_metadatum, class: Packages::ConanMetadatum do
+    package
+    package_username { 'username' }
+    package_channel { 'stable' }
+  end
+
+  factory :conan_file_metadatum, class: Packages::ConanFileMetadatum do
+    package_file
+    recipe_revision { '0' }
+
+    trait(:recipe_file) do
+      conan_file_type { 'recipe_file' }
+    end
+
+    trait(:package_file) do
+      conan_file_type { 'package_file' }
+      package_revision { '0' }
+      conan_package_reference { '123456789' }
+    end
+  end
 end

ee/spec/finders/packages/conan_package_finder_spec.rb

@@ -2,13 +2,14 @@
 require 'spec_helper'
 
 describe Packages::ConanPackageFinder do
+  let_it_be(:user) { create(:user) }
+  let_it_be(:project) { create(:project, :public) }
+
   describe '#execute' do
-    let_it_be(:user) { create(:user) }
-    let_it_be(:project) { create(:project, :public) }
     let!(:conan_package) { create(:conan_package, project: project) }
     let!(:conan_package2) { create(:conan_package, project: project) }
 
-    subject { described_class.new(query, user).execute }
+    subject { described_class.new(user, query: query).execute }
 
     context 'packages that are not visible to user' do
       let!(:non_visible_project) { create(:project, :private) }

ee/spec/fixtures/conan/package_conaninfo.txt

+[settings]
+    arch=x86_64
+    build_type=Release
+    compiler=apple-clang
+    compiler.libcxx=libc++
+    compiler.version=10.0
+    os=Macos
+
+[requires]
+
+
+[options]
+    shared=False
+
+[full_settings]
+    arch=x86_64
+    build_type=Release
+    compiler=apple-clang
+    compiler.libcxx=libc++
+    compiler.version=10.0
+    os=Macos
+
+[full_requires]
+
+
+[full_options]
+    shared=False
+
+[recipe_hash]
+    b4b91125b36b40a7076a98310588f820
+
+[env]
+

ee/spec/fixtures/conan/package_conanmanifest.txt

+1565723794
+conaninfo.txt: 2774ebe649804c1cd9430f26ab0ead14
+include/hello.h: 8727846905bd09baecf8bdc1edb1f46e
+lib/libhello.a: 7f2aaa8b6f3bc316bba59e47b6a0bd43

ee/spec/fixtures/conan/recipe_conanfile.py

+from conans import ConanFile, CMake, tools
+
+
+class HelloConan(ConanFile):
+    name = "Hello"
+    version = "0.1"
+    license = "<Put the package license here>"
+    author = "<Put your name here> <And your email here>"
+    url = "<Package recipe repository url here, for issues about the package>"
+    description = "<Description of Hello here>"
+    topics = ("<Put some tag here>", "<here>", "<and here>")
+    settings = "os", "compiler", "build_type", "arch"
+    options = {"shared": [True, False]}
+    default_options = "shared=False"
+    generators = "cmake"
+
+    def source(self):
+        self.run("git clone https://github.com/conan-io/hello.git")
+        # This small hack might be useful to guarantee proper /MT /MD linkage
+        # in MSVC if the packaged project doesn't have variables to set it
+        # properly
+        tools.replace_in_file("hello/CMakeLists.txt", "PROJECT(HelloWorld)",
+                              '''PROJECT(HelloWorld)
+include(${CMAKE_BINARY_DIR}/conanbuildinfo.cmake)
+conan_basic_setup()''')
+
+    def build(self):
+        cmake = CMake(self)
+        cmake.configure(source_folder="hello")
+        cmake.build()
+
+        # Explicit way:
+        # self.run('cmake %s/hello %s'
+        #          % (self.source_folder, cmake.command_line))
+        # self.run("cmake --build . %s" % cmake.build_config)
+
+    def package(self):
+        self.copy("*.h", dst="include", src="hello")
+        self.copy("*hello.lib", dst="lib", keep_path=False)
+        self.copy("*.dll", dst="bin", keep_path=False)
+        self.copy("*.so", dst="lib", keep_path=False)
+        self.copy("*.dylib", dst="lib", keep_path=False)
+        self.copy("*.a", dst="lib", keep_path=False)
+
+    def package_info(self):
+        self.cpp_info.libs = ["hello"]
+

ee/spec/fixtures/conan/recipe_conanmanifest.txt

+1565723790
+conanfile.py: 7c042b95312cc4c4ee89199dc51aebf9

ee/spec/lib/gitlab/regex_spec.rb

@@ -3,6 +3,45 @@
 require 'spec_helper'
 
 describe Gitlab::Regex do
+  describe '.conan_file_name_regex' do
+    subject { described_class.conan_file_name_regex }
+
+    it { is_expected.to match('conanfile.py') }
+    it { is_expected.to match('conan_package.tgz') }
+    it { is_expected.not_to match('foo.txt') }
+    it { is_expected.not_to match('!!()()') }
+  end
+
+  describe '.conan_package_reference_regex' do
+    subject { described_class.conan_package_reference_regex }
+
+    it { is_expected.to match('123456789') }
+    it { is_expected.to match('asdf1234') }
+    it { is_expected.not_to match('@foo') }
+    it { is_expected.not_to match('0/pack+age/1@1/0') }
+    it { is_expected.not_to match('!!()()') }
+  end
+
+  describe '.conan_revision_regex' do
+    subject { described_class.conan_revision_regex }
+
+    it { is_expected.to match('0') }
+    it { is_expected.not_to match('foo') }
+    it { is_expected.not_to match('!!()()') }
+  end
+
+  describe '.conan_recipe_component_regex' do
+    subject { described_class.conan_recipe_component_regex }
+
+    it { is_expected.to match('foobar') }
+    it { is_expected.to match('foo_bar') }
+    it { is_expected.to match('foo+bar') }
+    it { is_expected.to match('1.0.0') }
+    it { is_expected.not_to match('foo@bar') }
+    it { is_expected.not_to match('foo/bar') }
+    it { is_expected.not_to match('!!()()') }
+  end
+
   describe '.feature_flag_regex' do
     subject { described_class.feature_flag_regex }
 

ee/spec/models/packages/conan_file_metadatum_spec.rb

+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Packages::ConanFileMetadatum, type: :model do
+  describe 'relationships' do
+    it { is_expected.to belong_to(:package_file) }
+  end
+
+  describe 'validations' do
+    let(:package_file) do
+      create(:package_file,
+             file: fixture_file_upload('ee/spec/fixtures/conan/recipe_conanfile.py'),
+             file_name: 'recipe_conanfile.py')
+    end
+
+    it { is_expected.to validate_presence_of(:package_file) }
+    it { is_expected.to validate_presence_of(:recipe_revision) }
+
+    describe '#recipe_revision' do
+      it { is_expected.to allow_value("0").for(:recipe_revision) }
+      it { is_expected.not_to allow_value(nil).for(:recipe_revision) }
+    end
+
+    describe '#package_revision_for_package_file' do
+      context 'recipe file' do
+        let(:conan_file_metadatum) { build(:conan_file_metadatum, :recipe_file, package_file: package_file) }
+
+        it 'is valid with empty value' do
+          conan_file_metadatum.package_revision = nil
+
+          expect(conan_file_metadatum).to be_valid
+        end
+
+        it 'is invalid with value' do
+          conan_file_metadatum.package_revision = '0'
+
+          expect(conan_file_metadatum).to be_invalid
+        end
+      end
+
+      context 'package file' do
+        let(:conan_file_metadatum) { build(:conan_file_metadatum, :package_file, package_file: package_file) }
+
+        it 'is valid with default value' do
+          conan_file_metadatum.package_revision = '0'
+
+          expect(conan_file_metadatum).to be_valid
+        end
+
+        it 'is invalid with non-default value' do
+          conan_file_metadatum.package_revision = 'foo'
+
+          expect(conan_file_metadatum).to be_invalid
+        end
+      end
+    end
+
+    describe '#conan_package_reference_for_package_file' do
+      context 'recipe file' do
+        let(:conan_file_metadatum) { build(:conan_file_metadatum, :recipe_file, package_file: package_file) }
+
+        it 'is valid with empty value' do
+          conan_file_metadatum.conan_package_reference = nil
+
+          expect(conan_file_metadatum).to be_valid
+        end
+
+        it 'is invalid with value' do
+          conan_file_metadatum.conan_package_reference = '123456789'
+
+          expect(conan_file_metadatum).to be_invalid
+        end
+      end
+
+      context 'package file' do
+        let(:conan_file_metadatum) { build(:conan_file_metadatum, :package_file, package_file: package_file) }
+
+        it 'is valid with acceptable value' do
+          conan_file_metadatum.conan_package_reference = '123456asdf'
+
+          expect(conan_file_metadatum).to be_valid
+        end
+
+        it 'is invalid with invalid value' do
+          conan_file_metadatum.conan_package_reference = 'foo@bar'
+
+          expect(conan_file_metadatum).to be_invalid
+        end
+
+        it 'is invalid when nil' do
+          conan_file_metadatum.conan_package_reference = nil
+
+          expect(conan_file_metadatum).to be_invalid
+        end
+      end
+    end
+  end
+end

ee/spec/models/packages/conan_metadatum_spec.rb

+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Packages::ConanMetadatum, type: :model do
+  describe 'relationships' do
+    it { is_expected.to belong_to(:package) }
+  end
+
+  describe 'validations' do
+    it { is_expected.to validate_presence_of(:package) }
+    it { is_expected.to validate_presence_of(:package_username) }
+    it { is_expected.to validate_presence_of(:package_channel) }
+
+    describe '#package_username' do
+      it { is_expected.to allow_value("my-package+username").for(:package_username) }
+      it { is_expected.not_to allow_value("my/package").for(:package_username) }
+      it { is_expected.not_to allow_value("my(package)").for(:package_username) }
+      it { is_expected.not_to allow_value("my@package").for(:package_username) }
+    end
+
+    describe '#package_channel' do
+      it { is_expected.to allow_value("beta").for(:package_channel) }
+      it { is_expected.to allow_value("stable+1.0").for(:package_channel) }
+      it { is_expected.not_to allow_value("my/channel").for(:package_channel) }
+      it { is_expected.not_to allow_value("my(channel)").for(:package_channel) }
+      it { is_expected.not_to allow_value("my@channel").for(:package_channel) }
+    end
+  end
+
+  describe '#recipe' do
+    let(:package) { create(:conan_package) }
+
+    it 'returns the recipe' do
+      expect(package.conan_recipe).to eq("#{package.name}/#{package.version}@#{package.conan_metadatum.package_username}/#{package.conan_metadatum.package_channel}")
+    end
+  end
+
+  describe '#recipe_url' do
+    let(:package) { create(:conan_package) }
+
+    it 'returns the recipe url' do
+      expect(package.conan_recipe_path).to eq("#{package.name}/#{package.version}/#{package.conan_metadatum.package_username}/#{package.conan_metadatum.package_channel}")
+    end
+  end
+
+  describe '.package_username_from' do
+    let(:full_path) { 'foo/bar/baz-buz' }
+
+    it 'returns the username formatted package path' do
+      expect(described_class.package_username_from(full_path: full_path)).to eq('foo+bar+baz-buz')
+    end
+  end
+
+  describe '.full_path_from' do
+    let(:username) { 'foo+bar+baz-buz' }
+
+    it 'returns the username formatted package path' do
+      expect(described_class.full_path_from(package_username: username)).to eq('foo/bar/baz-buz')
+    end
+  end
+end

ee/spec/models/packages/package_file_spec.rb

@@ -4,6 +4,7 @@ require 'spec_helper'
 RSpec.describe Packages::PackageFile, type: :model do
   describe 'relationships' do
     it { is_expected.to belong_to(:package) }
+    it { is_expected.to have_one(:conan_file_metadatum) }
   end
 
   describe 'validations' do

ee/spec/presenters/conan_package_presenter_spec.rb

+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe ConanPackagePresenter do
+  let(:user) { create(:user) }
+  let(:project) { create(:project) }
+
+  describe '#recipe_urls' do
+    subject { described_class.new(recipe, user, project).recipe_urls }
+
+    context 'no existing package' do
+      let(:recipe) { "my-pkg/v1.0.0/#{project.full_path}/stable" }
+
+      it { is_expected.to be_empty }
+    end
+
+    context 'existing package' do
+      let(:package) { create(:conan_package, project: project) }
+      let(:recipe) { package.conan_recipe }
+
+      let(:expected_result) do
+        {
+          "recipe_conanfile.py" => "#{Settings.build_base_gitlab_url}/api/v4/packages/conan/v1/files/#{package.conan_recipe_path}/0/export/recipe_conanfile.py",
+          "recipe_conanmanifest.txt" => "#{Settings.build_base_gitlab_url}/api/v4/packages/conan/v1/files/#{package.conan_recipe_path}/0/export/recipe_conanmanifest.txt"
+        }
+      end
+
+      it { is_expected.to eq(expected_result) }
+    end
+  end
+
+  describe '#recipe_snapshot' do
+    subject { described_class.new(recipe, user, project).recipe_snapshot }
+
+    context 'no existing package' do
+      let(:recipe) { "my-pkg/v1.0.0/#{project.full_path}/stable" }
+
+      it { is_expected.to be_empty }
+    end
+
+    context 'existing package' do
+      let(:package) { create(:conan_package, project: project) }
+      let(:recipe) { package.conan_recipe }
+
+      let(:expected_result) do
+        {
+          "recipe_conanfile.py" => '12345abcde',
+          "recipe_conanmanifest.txt" => '12345abcde'
+        }
+      end
+
+      it { is_expected.to eq(expected_result) }
+    end
+  end
+
+  describe '#package_urls' do
+    subject { described_class.new(recipe, user, project).package_urls }
+
+    context 'no existing package' do
+      let(:recipe) { "my-pkg/v1.0.0/#{project.full_path}/stable" }
+
+      it { is_expected.to be_empty }
+    end
+
+    context 'existing package' do
+      let(:package) { create(:conan_package, project: project) }
+      let(:recipe) { package.conan_recipe }
+
+      let(:expected_result) do
+        {
+          "package_conaninfo.txt" => "#{Settings.build_base_gitlab_url}/api/v4/packages/conan/v1/files/#{package.conan_recipe_path}/0/package/123456789/0/package_conaninfo.txt",
+          "package_conanmanifest.txt" => "#{Settings.build_base_gitlab_url}/api/v4/packages/conan/v1/files/#{package.conan_recipe_path}/0/package/123456789/0/package_conanmanifest.txt",
+          "conan_package.tgz" => "#{Settings.build_base_gitlab_url}/api/v4/packages/conan/v1/files/#{package.conan_recipe_path}/0/package/123456789/0/conan_package.tgz"
+        }
+      end
+
+      it { is_expected.to eq(expected_result) }
+    end
+  end
+
+  describe '#package_snapshot' do
+    subject { described_class.new(recipe, user, project).package_snapshot }
+
+    context 'no existing package' do
+      let(:recipe) { "my-pkg/v1.0.0/#{project.full_path}/stable" }
+
+      it { is_expected.to be_empty }
+    end
+
+    context 'existing package' do
+      let(:package) { create(:conan_package, project: project) }
+      let(:recipe) { package.conan_recipe }
+
+      let(:expected_result) do
+        {
+          "package_conaninfo.txt" => '12345abcde',
+          "package_conanmanifest.txt" => '12345abcde',
+          "conan_package.tgz" => '12345abcde'
+        }
+      end
+
+      it { is_expected.to eq(expected_result) }
+    end
+  end
+end

ee/spec/requests/api/conan_packages_spec.rb

@@ -2,10 +2,16 @@
 require 'spec_helper'
 
 describe API::ConanPackages do
+  let_it_be(:package) { create(:conan_package) }
+  let_it_be(:personal_access_token) { create(:personal_access_token) }
+  let_it_be(:user) { personal_access_token.user }
+  let(:project) { package.project }
+
   let(:base_secret) { SecureRandom.base64(64) }
-  let(:personal_access_token) { create(:personal_access_token) }
+  let(:auth_token) { personal_access_token.token }
+
   let(:headers) do
-    { 'HTTP_AUTHORIZATION' => ActionController::HttpAuthentication::Basic.encode_credentials('foo', personal_access_token.token) }
+    { 'HTTP_AUTHORIZATION' => ActionController::HttpAuthentication::Basic.encode_credentials('foo', auth_token) }
   end
 
   let(:jwt_secret) do
@@ -17,21 +23,11 @@ describe API::ConanPackages do
   end
 
   before do
+    project.add_developer(user)
     stub_licensed_features(packages: true)
     allow(Settings).to receive(:attr_encrypted_db_key_base).and_return(base_secret)
   end
 
-  def build_jwt(personal_access_token, secret: jwt_secret, user_id: nil)
-    JSONWebToken::HMACToken.new(secret).tap do |jwt|
-      jwt['pat'] = personal_access_token.id
-      jwt['u'] = user_id || personal_access_token.user_id
-    end
-  end
-
-  def build_auth_headers(token)
-    { 'HTTP_AUTHORIZATION' => "Bearer #{token}" }
-  end
-
   describe 'GET /api/v4/packages/conan/v1/ping' do
     context 'feature flag disabled' do
       before do
@@ -99,53 +95,66 @@ describe API::ConanPackages do
   end
 
   describe 'GET /api/v4/packages/conan/v1/conans/search' do
-    let(:project) { create(:project, :public) }
-    let(:package) { create(:conan_package, project: project) }
-
     before do
+      project.update!(visibility_level: Gitlab::VisibilityLevel::PUBLIC)
+
       get api('/packages/conan/v1/conans/search'), headers: headers, params: params
     end
 
-    subject { JSON.parse(response.body)['results'] }
+    subject { json_response['results'] }
 
     context 'returns packages with a matching name' do
-      let(:params) { { q: package.name } }
+      let(:params) { { q: package.conan_recipe } }
 
-      it { is_expected.to contain_exactly(package.name) }
+      it { is_expected.to contain_exactly(package.conan_recipe) }
     end
 
     context 'returns packages using a * wildcard' do
-      let(:params) {{ q: "#{package.name[0, 3]}*" }}
+      let(:params) { { q: "#{package.name[0, 3]}*" } }
 
-      it { is_expected.to contain_exactly(package.name) }
+      it { is_expected.to contain_exactly(package.conan_recipe) }
     end
 
     context 'does not return non-matching packages' do
-      let(:params) {{ q: "foo" }}
+      let(:params) { { q: "foo" } }
 
       it { is_expected.to be_blank }
     end
   end
 
   describe 'GET /api/v4/packages/conan/v1/users/authenticate' do
-    it 'responds with 401 Unauthorized when invalid token is provided' do
-      headers = { 'HTTP_AUTHORIZATION' => ActionController::HttpAuthentication::Basic.encode_credentials('foo', 'wrong-token') }
-      get api('/packages/conan/v1/users/authenticate'), headers: headers
+    subject { get api('/packages/conan/v1/users/authenticate'), headers: headers }
 
-      expect(response).to have_gitlab_http_status(401)
+    context 'when using invalid token' do
+      let(:auth_token) { 'invalid_token' }
+
+      it 'responds with 401' do
+        subject
+
+        expect(response).to have_gitlab_http_status(401)
+      end
     end
 
-    it 'responds with 200 OK and JWT when valid access token is provided' do
-      get api('/packages/conan/v1/users/authenticate'), headers: headers
+    context 'when valid JWT access token is provided' do
+      it 'responds with 200' do
+        subject
 
-      expect(response).to have_gitlab_http_status(200)
+        expect(response).to have_gitlab_http_status(200)
+      end
 
-      payload = JSONWebToken::HMACToken.decode(response.body, jwt_secret).first
-      expect(payload['pat']).to eq(personal_access_token.id)
-      expect(payload['u']).to eq(personal_access_token.user_id)
+      it 'token has valid validity time' do
+        Timecop.freeze do
+          subject
+
+          payload = JSONWebToken::HMACToken.decode(
+            response.body, jwt_secret).first
+          expect(payload['pat']).to eq(personal_access_token.id)
+          expect(payload['u']).to eq(personal_access_token.user_id)
 
-      duration = payload['exp'] - payload['iat']
-      expect(duration).to eq(1.hour)
+          duration = payload['exp'] - payload['iat']
+          expect(duration).to eq(1.hour)
+        end
+      end
     end
   end
 
@@ -163,9 +172,10 @@ describe API::ConanPackages do
     end
   end
 
-  shared_examples 'rejected invalid recipe' do
-    context 'with invalid recipe url' do
-      let(:recipe) { '../../foo++../..' }
+  shared_examples 'rejects invalid recipe' do
+    context 'with invalid recipe path' do
+      let(:recipe_path) { '../../foo++../..' }
+
       it 'returns 400' do
         subject
 
@@ -174,103 +184,295 @@ describe API::ConanPackages do
     end
   end
 
+  shared_examples 'rejects recipe for invalid project' do
+    context 'with invalid recipe path' do
+      let(:recipe_path) { 'aa/bb/not-existing-project/ccc' }
+
+      it 'returns forbidden' do
+        subject
+
+        expect(response).to have_gitlab_http_status(:forbidden)
+      end
+    end
+  end
+
+  shared_examples 'rejects recipe for not found package' do
+    context 'with invalid recipe path' do
+      let(:recipe_path) do
+        'aa/bb/%{project}/ccc' % { project: ::Packages::ConanMetadatum.package_username_from(full_path: project.full_path) }
+      end
+
+      it 'returns not found' do
+        subject
+
+        expect(response).to have_gitlab_http_status(:not_found)
+      end
+    end
+  end
+
+  shared_examples 'empty recipe for not found package' do
+    context 'with invalid recipe url' do
+      let(:recipe_path) do
+        'aa/bb/%{project}/ccc' % { project: ::Packages::ConanMetadatum.package_username_from(full_path: project.full_path) }
+      end
+
+      it 'returns not found' do
+        allow(ConanPackagePresenter).to receive(:new)
+          .with(
+            'aa/bb@%{project}/ccc' % { project: ::Packages::ConanMetadatum.package_username_from(full_path: project.full_path) },
+            user,
+            project
+          ).and_return(presenter)
+        allow(presenter).to receive(:recipe_snapshot) { {} }
+        allow(presenter).to receive(:package_snapshot) { {} }
+
+        subject
+
+        expect(response).to have_gitlab_http_status(:ok)
+        expect(response.body).to eq("{}")
+      end
+    end
+  end
+
   context 'recipe endpoints' do
     let(:jwt) { build_jwt(personal_access_token) }
     let(:headers) { build_auth_headers(jwt.encoded) }
-    let(:recipe) { 'my-package-name/1.0/username/channel' }
+    let(:package_id) { '123456789' }
+    let(:presenter) { double('ConanPackagePresenter') }
+
+    before do
+      allow(ConanPackagePresenter).to receive(:new)
+        .with(package.conan_recipe, user, package.project)
+        .and_return(presenter)
+    end
 
-    describe 'GET /api/v4/packages/conan/v1/conans/*recipe' do
-      subject { get api("/packages/conan/v1/conans/#{recipe}"), headers: headers }
+    describe 'GET /api/v4/packages/conan/v1/conans/:package_name/package_version/:package_username/:package_channel' do
+      let(:recipe_path) { package.conan_recipe_path }
 
-      it_behaves_like 'rejected invalid recipe'
+      subject { get api("/packages/conan/v1/conans/#{recipe_path}"), headers: headers }
 
-      it 'responds with an empty response' do
-        subject
+      it_behaves_like 'rejects invalid recipe'
+      it_behaves_like 'rejects recipe for invalid project'
+      it_behaves_like 'empty recipe for not found package'
+
+      context 'with existing package' do
+        it 'returns a hash of files with their md5 hashes' do
+          expected_response = {
+            'conanfile.py'      => 'md5hash1',
+            'conanmanifest.txt' => 'md5hash2'
+          }
 
-        expect(response.body).to be {}
+          allow(presenter).to receive(:recipe_snapshot) { expected_response }
+
+          subject
+
+          expect(json_response).to eq(expected_response)
+        end
       end
     end
 
-    describe 'GET /api/v4/packages/conan/v1/conans/*recipe/digest' do
-      subject { get api("/packages/conan/v1/conans/#{recipe}/digest"), headers: headers }
+    describe 'GET /api/v4/packages/conan/v1/conans/:package_name/package_version/:package_username/:package_channel/packages/:package_id' do
+      let(:recipe_path) { package.conan_recipe_path }
 
-      it_behaves_like 'rejected invalid recipe'
+      subject { get api("/packages/conan/v1/conans/#{recipe_path}/packages/#{package_id}"), headers: headers }
 
-      it 'responds with a 404' do
-        subject
+      it_behaves_like 'rejects invalid recipe'
+      it_behaves_like 'rejects recipe for invalid project'
+      it_behaves_like 'empty recipe for not found package'
 
-        expect(response).to have_gitlab_http_status(404)
+      context 'with existing package' do
+        it 'returns a hash of md5 values for the files' do
+          expected_response = {
+            'conaninfo.txt'     => "md5hash1",
+            'conanmanifest.txt' => "md5hash2",
+            'conan_package.tgz' => "md5hash3"
+          }
+
+          allow(presenter).to receive(:package_snapshot) { expected_response }
+
+          subject
+
+          expect(json_response).to eq(expected_response)
+        end
+      end
+    end
+
+    describe 'GET /api/v4/packages/conan/v1/conans/:package_name/package_version/:package_username/:package_channel/digest' do
+      subject { get api("/packages/conan/v1/conans/#{recipe_path}/digest"), headers: headers }
+
+      it_behaves_like 'rejects invalid recipe'
+      it_behaves_like 'rejects recipe for invalid project'
+
+      context 'with existing package' do
+        let(:recipe_path) { package.conan_recipe_path }
+
+        it 'returns the download urls for each package file' do
+          expected_response = {
+            'conanfile.py'      => "#{Settings.gitlab.base_url}/api/v4/packages/conan/v1/files/#{package.conan_recipe_path}/0/export/conanfile.py",
+            'conanmanifest.txt' => "#{Settings.gitlab.base_url}/api/v4/packages/conan/v1/files/#{package.conan_recipe_path}/0/export/conanmanifest.txt"
+          }
+
+          allow(presenter).to receive(:recipe_urls) { expected_response }
+
+          subject
+
+          expect(json_response).to eq(expected_response)
+        end
       end
     end
 
-    describe 'GET /api/v4/packages/conan/v1/conans/*recipe/upload_urls' do
+    describe 'GET /api/v4/packages/conan/v1/conans/:package_name/package_version/:package_username/:package_channel/packages/:package_id/digest' do
+      subject { get api("/packages/conan/v1/conans/#{recipe_path}/packages/#{package_id}/digest"), headers: headers }
+
+      it_behaves_like 'rejects invalid recipe'
+      it_behaves_like 'rejects recipe for invalid project'
+
+      context 'with existing package' do
+        let(:recipe_path) { package.conan_recipe_path }
+
+        it 'returns the download urls for the files' do
+          expected_response = {
+            'conaninfo.txt'     => "#{Settings.gitlab.base_url}/api/v4/packages/conan/v1/files/#{package.conan_recipe_path}/0/package/123456789/0/conaninfo.txt",
+            'conanmanifest.txt' => "#{Settings.gitlab.base_url}/api/v4/packages/conan/v1/files/#{package.conan_recipe_path}/0/package/123456789/0/conanmanifest.txt",
+            'conan_package.tgz' => "#{Settings.gitlab.base_url}/api/v4/packages/conan/v1/files/#{package.conan_recipe_path}/0/package/123456789/0/conan_package.tgz"
+          }
+
+          allow(presenter).to receive(:package_urls) { expected_response }
+
+          subject
+
+          expect(json_response).to eq(expected_response)
+        end
+      end
+    end
+
+    describe 'POST /api/v4/packages/conan/v1/conans/:package_name/package_version/:package_username/:package_channel/upload_urls' do
+      let(:recipe_path) { package.conan_recipe_path }
+
       let(:params) do
         { "conanfile.py": 24,
           "conanmanifext.txt": 123 }
       end
-      subject { post api("/packages/conan/v1/conans/#{recipe}/upload_urls"), params: params, headers: headers }
 
-      it_behaves_like 'rejected invalid recipe'
+      subject { post api("/packages/conan/v1/conans/#{recipe_path}/upload_urls"), params: params, headers: headers }
+
+      it_behaves_like 'rejects invalid recipe'
 
       it 'returns a set of upload urls for the files requested' do
         subject
 
         expected_response = {
-          'conanfile.py':      "#{Settings.gitlab.base_url}/api/v4/packages/conan/v1/files/#{recipe}/-/0/export/conanfile.py",
-          'conanmanifest.txt': "#{Settings.gitlab.base_url}/api/v4/packages/conan/v1/files/#{recipe}/-/0/export/conanmanifest.txt"
+          'conanfile.py':      "#{Settings.gitlab.base_url}/api/v4/packages/conan/v1/files/#{package.conan_recipe_path}/0/export/conanfile.py",
+          'conanmanifest.txt': "#{Settings.gitlab.base_url}/api/v4/packages/conan/v1/files/#{package.conan_recipe_path}/0/export/conanmanifest.txt"
         }
 
-        expect(response.body).to eq expected_response.to_json
+        expect(response.body).to eq(expected_response.to_json)
       end
     end
 
-    describe 'GET /api/v4/packages/conan/v1/conans/*recipe/packages/:package_id' do
-      subject { get api("/packages/conan/v1/conans/#{recipe}/packages/123456789"), headers: headers }
+    describe 'POST /api/v4/packages/conan/v1/conans/:package_name/package_version/:package_username/:package_channel/packages/:package_id/upload_urls' do
+      let(:recipe_path) { package.conan_recipe_path }
 
-      it_behaves_like 'rejected invalid recipe'
+      let(:params) do
+        { "conaninfo.txt": 24,
+          "conanmanifext.txt": 123,
+          "conan_package.tgz": 523 }
+      end
+
+      subject { post api("/packages/conan/v1/conans/#{recipe_path}/packages/123456789/upload_urls"), params: params, headers: headers }
+
+      it_behaves_like 'rejects invalid recipe'
+
+      it 'returns a set of upload urls for the files requested' do
+        expected_response = {
+          'conaninfo.txt':     "#{Settings.gitlab.base_url}/api/v4/packages/conan/v1/files/#{package.conan_recipe_path}/0/package/123456789/0/conaninfo.txt",
+          'conanmanifest.txt': "#{Settings.gitlab.base_url}/api/v4/packages/conan/v1/files/#{package.conan_recipe_path}/0/package/123456789/0/conanmanifest.txt",
+          'conan_package.tgz': "#{Settings.gitlab.base_url}/api/v4/packages/conan/v1/files/#{package.conan_recipe_path}/0/package/123456789/0/conan_package.tgz"
+        }
 
-      it 'responds with an empty response' do
         subject
 
-        expect(response.body).to be {}
+        expect(response.body).to eq(expected_response.to_json)
       end
     end
+  end
 
-    describe 'GET /api/v4/packages/conan/v1/conans/*recipe/packages/:package_id/digest' do
-      subject { get api("/packages/conan/v1/conans/#{recipe}/packages/123456789/digest"), headers: headers }
+  context 'file endpoints' do
+    let(:jwt) { build_jwt(personal_access_token) }
+    let(:headers) { build_auth_headers(jwt.encoded) }
+    let(:package_file_tgz) { package.package_files.find_by(file_type: 'tgz') }
+    let(:metadata) { package_file_tgz.conan_file_metadatum }
 
-      it_behaves_like 'rejected invalid recipe'
+    describe 'GET /api/v4/packages/conan/v1/files/:package_name/package_version/:package_username/:package_channel/
+:recipe_revision/export/:file_name' do
+      let(:recipe_path) { package.conan_recipe_path }
 
-      it 'responds with a 404' do
-        subject
+      subject do
+        get api("/packages/conan/v1/files/#{recipe_path}/#{metadata.recipe_revision}/export/#{file_name}"),
+            headers: headers
+      end
 
-        expect(response).to have_gitlab_http_status(404)
+      context 'invalid file' do
+        let(:file_name) { 'badfile.txt' }
+
+        it 'returns 404 not found' do
+          subject
+
+          expect(response).to have_gitlab_http_status(:not_found)
+        end
+      end
+
+      context 'valid file' do
+        let(:file_name) { package_file_tgz.file_name }
+
+        it 'returns forbidden' do
+          subject
+
+          expect(response).to have_gitlab_http_status(:not_found)
+        end
       end
     end
 
-    describe 'GET /api/v4/packages/conan/v1/conans/*recipe/packages/:package_id/upload_urls' do
-      let(:params) do
-        { "conaninfo.txt": 24,
-          "conanmanifext.txt": 123,
-          "conan_package.tgz": 523 }
+    describe 'GET /api/v4/packages/conan/v1/files/:package_name/package_version/:package_username/:package_channel/
+:recipe_revision/package/:conan_package_reference/:package_revision/:file_name' do
+      let(:recipe_path) { package.conan_recipe_path }
+
+      subject do
+        get api("/packages/conan/v1/files/#{recipe_path}/#{metadata.recipe_revision}/package/" \
+              "#{metadata.conan_package_reference}/#{metadata.package_revision}/#{file_name}"),
+            headers: headers
       end
 
-      context 'valid recipe' do
-        subject { post api("/packages/conan/v1/conans/#{recipe}/packages/123456789/upload_urls"), params: params, headers: headers }
+      context 'invalid file' do
+        let(:file_name) { 'badfile.txt' }
 
-        it_behaves_like 'rejected invalid recipe'
+        it 'returns 404 not found' do
+          subject
 
-        it 'returns a set of upload urls for the files requested' do
-          expected_response = {
-            'conaninfo.txt':     "#{Settings.gitlab.base_url}/api/v4/packages/conan/v1/files/#{recipe}/-/0/package/123456789/0/conaninfo.txt",
-            'conanmanifest.txt': "#{Settings.gitlab.base_url}/api/v4/packages/conan/v1/files/#{recipe}/-/0/package/123456789/0/conanmanifest.txt",
-            'conan_package.tgz': "#{Settings.gitlab.base_url}/api/v4/packages/conan/v1/files/#{recipe}/-/0/package/123456789/0/conan_package.tgz"
-          }
+          expect(response).to have_gitlab_http_status(:not_found)
+        end
+      end
+
+      context 'valid file' do
+        let(:file_name) { package_file_tgz.file_name }
+
+        it 'returns forbidden' do
           subject
 
-          expect(response.body).to eq expected_response.to_json
+          expect(response).to have_gitlab_http_status(:not_found)
         end
       end
     end
   end
+
+  def build_jwt(personal_access_token, secret: jwt_secret, user_id: nil)
+    JSONWebToken::HMACToken.new(secret).tap do |jwt|
+      jwt['pat'] = personal_access_token.id
+      jwt['u'] = user_id || personal_access_token.user_id
+    end
+  end
+
+  def build_auth_headers(token)
+    { 'HTTP_AUTHORIZATION' => "Bearer #{token}" }
+  end
 end

ee/spec/services/packages/conan/search_service_spec.rb

@@ -10,6 +10,10 @@ describe Packages::Conan::SearchService do
 
   subject { described_class.new(user, query: query) }
 
+  before do
+    project.add_developer(user)
+  end
+
   describe '#execute' do
     context 'feature unavailable' do
       let(:query) { '' }
@@ -34,7 +38,7 @@ describe Packages::Conan::SearchService do
         result = subject.execute
 
         expect(result.status).to eq :success
-        expect(result.payload).to eq(results: [conan_package.name, conan_package2.name])
+        expect(result.payload).to eq(results: [conan_package.conan_recipe, conan_package2.conan_recipe])
       end
     end
 
@@ -50,24 +54,24 @@ describe Packages::Conan::SearchService do
     end
 
     context 'with no wildcard' do
-      let(:query) { conan_package.name.split('/').first }
+      let(:query) { conan_package.name }
 
       it 'makes a search using the beginning of the recipe' do
         result = subject.execute
 
         expect(result.status).to eq :success
-        expect(result.payload).to eq(results: [conan_package.name])
+        expect(result.payload).to eq(results: [conan_package.conan_recipe])
       end
     end
 
     context 'with full recipe match' do
-      let(:query) { conan_package.name }
+      let(:query) { conan_package.conan_recipe }
 
       it 'makes an exact search' do
         result = subject.execute
 
         expect(result.status).to eq :success
-        expect(result.payload).to eq(results: [conan_package.name])
+        expect(result.payload).to eq(results: [conan_package.conan_recipe])
       end
     end