katello 3.17.0.rc1 → 3.17.0.rc2

data/app/views/katello/api/v2/content_view_version_export_histories/index.json.rabl

@@ -0,0 +1,7 @@
+object false
+
+extends "katello/api/v2/common/metadata"
+
+child @collection[:results] => :results do
+  extends 'katello/api/v2/content_view_version_export_histories/show'
+end

data/app/views/katello/api/v2/content_view_version_export_histories/show.json.rabl

@@ -0,0 +1,13 @@
+object @resource
+
+attributes :destination_server, :path, :id
+
+node :content_view_version do |h|
+  h.content_view_version.name
+end
+
+node :content_view_version_id do |h|
+  h.content_view_version.id
+end
+
+extends 'katello/api/v2/common/timestamps'

data/app/views/katello/api/v2/package_groups/show.json.rabl

@@ -1,4 +1,4 @@
 object @resource
 
 extends "katello/api/v2/package_groups/base"
-extends "katello/api/v2/package_groups/backend", :object => SmartProxy.pulp_master.pulp3_repository_type_support?('yum') ? Katello::Pulp3::PackageGroup.new(@resource.pulp_id) : Katello::Pulp::PackageGroup.new(@resource.pulp_id)
+extends "katello/api/v2/package_groups/backend", :object => SmartProxy.pulp_primary.pulp3_repository_type_support?('yum') ? Katello::Pulp3::PackageGroup.new(@resource.pulp_id) : Katello::Pulp::PackageGroup.new(@resource.pulp_id)

data/app/views/katello/api/v2/packages/show.json.rabl

@@ -2,4 +2,4 @@ object @resource
 
 extends "katello/api/v2/packages/base"
 extends "katello/api/v2/packages/backend",
-  :object => SmartProxy.pulp_master!.content_service("rpm").new(@resource.pulp_id)
+  :object => SmartProxy.pulp_primary!.content_service("rpm").new(@resource.pulp_id)

data/app/views/katello/api/v2/repositories/base.json.rabl

@@ -4,9 +4,10 @@ extends 'katello/api/v2/common/identifier'
 
 attributes :pulp_id => :backend_identifier
 attributes :relative_path, :container_repository_name, :full_path, :library_instance_id
+attributes :version_href, :remote_href, :publication_href
 
 glue(@object.root) do
-  attributes :content_type, :url, :arch, :content_id, :auto_enabled
+  attributes :content_type, :url, :arch, :content_id
   attributes :major, :minor
 
   child :product do |_product|

data/app/views/katello/api/v2/srpms/show.json.rabl

@@ -2,4 +2,4 @@ object @resource
 
 extends "katello/api/v2/srpms/base"
 extends "katello/api/v2/srpms/backend",
-  :object => SmartProxy.pulp_master!.content_service("srpm").new(@resource.pulp_id)
+  :object => SmartProxy.pulp_primary!.content_service("srpm").new(@resource.pulp_id)

data/app/views/katello/api/v2/sync_plans/show.json.rabl

@@ -2,7 +2,8 @@ object @resource
 
 attributes :id, :organization_id
 attributes :name, :description
-attributes :interval, :next_sync, :sync_date
+attributes :interval, :next_sync
+attributes :sync_date_sans_tz => :sync_date
 attributes :created_at, :updated_at
 attributes :enabled, :foreman_tasks_recurring_logic_id
 attributes :cron_expression

data/config/routes/api/rhsm.rb

@@ -21,6 +21,7 @@ Katello::Engine.routes.draw do
       match '/owners/:organization_id/environments' => 'candlepin_proxies#rhsm_index', :via => :get
       match '/owners/:organization_id/pools' => 'candlepin_proxies#get', :via => :get, :as => :proxy_owner_pools_path
       match '/owners/:organization_id/servicelevels' => 'candlepin_proxies#get', :via => :get, :as => :proxy_owner_servicelevels_path
+      match '/owners/:organization_id/system_purpose' => 'candlepin_proxies#get', :via => :get, :as => :proxy_owner_system_purpose_path
       match '/environments/:environment_id/consumers' => 'candlepin_proxies#consumer_create', :via => :post
       match '/consumers/:id' => 'candlepin_proxies#consumer_show', :via => :get
       match '/consumers/:id' => 'candlepin_proxies#regenerate_identity_certificates', :via => :post

data/config/routes/api/v2.rb

@@ -96,7 +96,11 @@ Katello::Engine.routes.draw do
             end
           end
           api_resources :puppet_modules, :only => [:index]
-          api_resources :repositories, :only => [:index]
+          api_resources :repositories, :only => [:index] do
+            collection do
+              match '/show_all' => "content_view_repositories#show_all", :via => :get
+            end
+          end
           api_resources :content_view_versions, :only => [:index]
         end
 
@@ -117,6 +121,7 @@ Katello::Engine.routes.draw do
             get :available_errata, :controller => :errata
           end
           collection do
+            get :export_histories
             get :auto_complete_search
             post :incremental_update
           end
@@ -394,6 +399,7 @@ Katello::Engine.routes.draw do
             put :remove_docker_manifests, :action => :remove_content
             put :remove_content
             post :sync
+            post :verify_checksum
             post :export
             post :upload_content
             put :import_uploads
@@ -423,6 +429,7 @@ Katello::Engine.routes.draw do
           collection do
             match '/bulk/destroy' => 'products_bulk_actions#destroy_products', :via => :put
             match '/bulk/sync' => 'products_bulk_actions#sync_products', :via => :put
+            match '/bulk/verify_checksum' => 'products_bulk_actions#verify_checksum_products', :via => :put
             match '/bulk/sync_plan' => 'products_bulk_actions#update_sync_plans', :via => :put
             match '/bulk/http_proxy' => 'products_bulk_actions#update_http_proxy', :via => :put
           end

data/db/migrate/20200818040551_add_content_view_version_export_history.rb

@@ -0,0 +1,13 @@
+class AddContentViewVersionExportHistory < ActiveRecord::Migration[6.0]
+  def change
+    create_table :katello_content_view_version_export_histories do |t|
+      t.timestamps
+      t.string :destination_server
+      t.string :path
+      t.references :content_view_version, index: { name: :katello_cvv_export_history_cvv_id }
+    end
+
+    add_index :katello_content_view_version_export_histories, [:destination_server, :content_view_version_id, :path],
+              unique: true, name: :katello_cvv_export_history_sat_cvv_id_path_destination
+  end
+end

data/db/migrate/20200818192230_update_system_purpose_status.rb

@@ -0,0 +1,12 @@
+class UpdateSystemPurposeStatus < ActiveRecord::Migration[6.0]
+  def change
+    purpose_types = Katello::HostStatusManager::PURPOSE_STATUS.map(&:to_s)
+
+    # load both sets of host statuses and *then* update them to make sure we update the correct statuses
+    unknown_statuses = ::HostStatus::Status.where(type: purpose_types, status: 2).pluck(:id)
+    matched_statuses = ::HostStatus::Status.where(type: purpose_types, status: 0).pluck(:id)
+
+    ::HostStatus::Status.where(id: unknown_statuses).update_all(status: Katello::PurposeStatus::UNKNOWN) # 2 => 0
+    ::HostStatus::Status.where(id: matched_statuses).update_all(status: Katello::PurposeStatus::MATCHED) # 0 => 2
+  end
+end

data/db/migrate/20200820145217_add_download_concurrency_to_katello_root_repositories.rb

@@ -0,0 +1,5 @@
+class AddDownloadConcurrencyToKatelloRootRepositories < ActiveRecord::Migration[6.0]
+  def change
+    add_column :katello_root_repositories, :download_concurrency, :integer
+  end
+end

data/db/migrate/20200910140340_remove_distribution_uuid.rb

@@ -0,0 +1,5 @@
+class RemoveDistributionUuid < ActiveRecord::Migration[6.0]
+  def change
+    remove_column :katello_repositories, :distribution_uuid, :string
+  end
+end

data/db/migrate/20200914200906_remove_auto_enabled.rb

@@ -0,0 +1,5 @@
+class RemoveAutoEnabled < ActiveRecord::Migration[6.0]
+  def change
+    remove_column :katello_root_repositories, :auto_enabled
+  end
+end

data/engines/bastion/app/assets/javascripts/bastion/bastion.js

@@ -4,6 +4,7 @@
 //= require "bastion/angular-sanitize/angular-sanitize"
 //= require "bastion/angular-patternfly/angular-patternfly.js"
 //= require "bastion/angular-ui-router/angular-ui-router"
+//= require "bastion/angular-ui-router/stateEvents"
 //= require "bastion/angular-uuid4/angular-uuid4.js"
 //= require "bastion/ngUpload/ng-upload"
 //= require "bastion/angular-gettext/angular-gettext"

data/engines/bastion/app/assets/javascripts/bastion/routing.module.js

@@ -1,4 +1,4 @@
-angular.module('Bastion.routing', ['ui.router']);
+angular.module('Bastion.routing', ['ui.router', 'ui.router.state.events']);
 
 (function () {
     'use strict';

data/engines/bastion/vendor/assets/javascripts/bastion/angular-ui-router/stateEvents.js

@@ -0,0 +1,300 @@
+/**
+ * State-based routing for AngularJS 1.x
+ * @version v1.0.25
+ * @link https://ui-router.github.io
+ * @license MIT License, http://www.opensource.org/licenses/MIT
+ */
+(function (global, factory) {
+    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('angular')) :
+    typeof define === 'function' && define.amd ? define(['exports', 'angular'], factory) :
+    (global = global || self, factory(global['@uirouter/angularjs-state-events'] = {}, global.angular));
+}(this, (function (exports, ng_from_import) { 'use strict';
+
+    /** @publicapi @module ng1 */ /** */
+    /** @hidden */ var ng_from_global = angular;
+    /** @hidden */ var ng = ng_from_import && ng_from_import.module ? ng_from_import : ng_from_global;
+
+    /**
+     * # Legacy state events
+     *
+     * Polyfill implementation of the UI-Router 0.2.x state events.
+     *
+     * The 0.2.x state events are deprecated.  We recommend moving to Transition Hooks instead, as they
+     * provide much more flexibility, support async, and provide the context (the Transition, etc) necessary
+     * to implement meaningful application behaviors.
+     *
+     * To enable these state events, include the `stateEvents.js` file in your project, e.g.,
+     * ```
+     * <script src="stateEvents.js"></script>
+     * ```
+     * and also make sure you depend on the `ui.router.state.events` angular module, e.g.,
+     * ```
+     * angular.module("myApplication", ['ui.router', 'ui.router.state.events']
+     * ```
+     *
+     * @publicapi @module ng1_state_events
+     */ /** */
+    /**
+     * An event broadcast on `$rootScope` when the state transition **begins**.
+     *
+     * ### Deprecation warning: use [[TransitionService.onStart]] instead
+     *
+     * You can use `event.preventDefault()`
+     * to prevent the transition from happening and then the transition promise will be
+     * rejected with a `'transition prevented'` value.
+     *
+     * Additional arguments to the event handler are provided:
+     * - `toState`: the Transition Target state
+     * - `toParams`: the Transition Target Params
+     * - `fromState`: the state the transition is coming from
+     * - `fromParams`: the parameters from the state the transition is coming from
+     * - `options`: any Transition Options
+     * - `$transition$`: the [[Transition]]
+     *
+     * #### Example:
+     * ```js
+     * $rootScope.$on('$stateChangeStart', function(event, transition) {
+     *   event.preventDefault();
+     *   // transitionTo() promise will be rejected with
+     *   // a 'transition prevented' error
+     * })
+     * ```
+     *
+     * @event $stateChangeStart
+     * @deprecated
+     */
+    var $stateChangeStart;
+    /**
+     * An event broadcast on `$rootScope` if a transition is **cancelled**.
+     *
+     * ### Deprecation warning: use [[TransitionService.onStart]] instead
+     *
+     * Additional arguments to the event handler are provided:
+     * - `toState`: the Transition Target state
+     * - `toParams`: the Transition Target Params
+     * - `fromState`: the state the transition is coming from
+     * - `fromParams`: the parameters from the state the transition is coming from
+     * - `options`: any Transition Options
+     * - `$transition$`: the [[Transition]] that was cancelled
+     *
+     * @event $stateChangeCancel
+     * @deprecated
+     */
+    var $stateChangeCancel;
+    /**
+     * An event broadcast on `$rootScope` once the state transition is **complete**.
+     *
+     * ### Deprecation warning: use [[TransitionService.onStart]] and [[Transition.promise]], or [[Transition.onSuccess]]
+     *
+     * Additional arguments to the event handler are provided:
+     * - `toState`: the Transition Target state
+     * - `toParams`: the Transition Target Params
+     * - `fromState`: the state the transition is coming from
+     * - `fromParams`: the parameters from the state the transition is coming from
+     * - `options`: any Transition Options
+     * - `$transition$`: the [[Transition]] that just succeeded
+     *
+     * @event $stateChangeSuccess
+     * @deprecated
+     */
+    var $stateChangeSuccess;
+    /**
+     * An event broadcast on `$rootScope` when an **error occurs** during transition.
+     *
+     * ### Deprecation warning: use [[TransitionService.onStart]] and [[Transition.promise]], or [[Transition.onError]]
+     *
+     * It's important to note that if you
+     * have any errors in your resolve functions (javascript errors, non-existent services, etc)
+     * they will not throw traditionally. You must listen for this $stateChangeError event to
+     * catch **ALL** errors.
+     *
+     * Additional arguments to the event handler are provided:
+     * - `toState`: the Transition Target state
+     * - `toParams`: the Transition Target Params
+     * - `fromState`: the state the transition is coming from
+     * - `fromParams`: the parameters from the state the transition is coming from
+     * - `error`: The reason the transition errored.
+     * - `options`: any Transition Options
+     * - `$transition$`: the [[Transition]] that errored
+     *
+     * @event $stateChangeError
+     * @deprecated
+     */
+    var $stateChangeError;
+    /**
+     * An event broadcast on `$rootScope` when a requested state **cannot be found** using the provided state name.
+     *
+     * ### Deprecation warning: use [[StateService.onInvalid]] instead
+     *
+     * The event is broadcast allowing any handlers a single chance to deal with the error (usually by
+     * lazy-loading the unfound state). A `TargetState` object is passed to the listener handler,
+     * you can see its properties in the example. You can use `event.preventDefault()` to abort the
+     * transition and the promise returned from `transitionTo()` will be rejected with a
+     * `'transition aborted'` error.
+     *
+     * Additional arguments to the event handler are provided:
+     * - `unfoundState` Unfound State information. Contains: `to, toParams, options` properties.
+     * - `fromState`: the state the transition is coming from
+     * - `fromParams`: the parameters from the state the transition is coming from
+     * - `options`: any Transition Options
+     *
+     * #### Example:
+     * ```js
+     * // somewhere, assume lazy.state has not been defined
+     * $state.go("lazy.state", { a: 1, b: 2 }, { inherit: false });
+     *
+     * // somewhere else
+     * $scope.$on('$stateNotFound', function(event, transition) {
+     * function(event, unfoundState, fromState, fromParams){
+     *     console.log(unfoundState.to); // "lazy.state"
+     *     console.log(unfoundState.toParams); // {a:1, b:2}
+     *     console.log(unfoundState.options); // {inherit:false} + default options
+     * });
+     * ```
+     *
+     * @event $stateNotFound
+     * @deprecated
+     */
+    var $stateNotFound;
+    (function () {
+        var isFunction = ng.isFunction, isString = ng.isString;
+        function applyPairs(memo, keyValTuple) {
+            var key, value;
+            if (Array.isArray(keyValTuple))
+                key = keyValTuple[0], value = keyValTuple[1];
+            if (!isString(key))
+                throw new Error('invalid parameters to applyPairs');
+            memo[key] = value;
+            return memo;
+        }
+        function stateChangeStartHandler($transition$) {
+            if (!$transition$.options().notify || !$transition$.valid() || $transition$.ignored())
+                return;
+            var $injector = $transition$.injector();
+            var $stateEvents = $injector.get('$stateEvents');
+            var $rootScope = $injector.get('$rootScope');
+            var $state = $injector.get('$state');
+            var $urlRouter = $injector.get('$urlRouter');
+            var enabledEvents = $stateEvents.provider.enabled();
+            var toParams = $transition$.params('to');
+            var fromParams = $transition$.params('from');
+            if (enabledEvents.$stateChangeSuccess) {
+                var startEvent = $rootScope.$broadcast('$stateChangeStart', $transition$.to(), toParams, $transition$.from(), fromParams, $transition$.options(), $transition$);
+                if (startEvent.defaultPrevented) {
+                    if (enabledEvents.$stateChangeCancel) {
+                        $rootScope.$broadcast('$stateChangeCancel', $transition$.to(), toParams, $transition$.from(), fromParams, $transition$.options(), $transition$);
+                    }
+                    // Don't update and resync url if there's been a new transition started. see issue #2238, #600
+                    if ($state.transition == null)
+                        $urlRouter.update();
+                    return false;
+                }
+                // right after global state is updated
+                var successOpts = { priority: 9999 };
+                $transition$.onSuccess({}, function () {
+                    $rootScope.$broadcast('$stateChangeSuccess', $transition$.to(), toParams, $transition$.from(), fromParams, $transition$.options(), $transition$);
+                }, successOpts);
+            }
+            if (enabledEvents.$stateChangeError) {
+                $transition$.promise['catch'](function (error) {
+                    if (error && (error.type === 2 /* RejectType.SUPERSEDED */ || error.type === 3) /* RejectType.ABORTED */)
+                        return;
+                    var evt = $rootScope.$broadcast('$stateChangeError', $transition$.to(), toParams, $transition$.from(), fromParams, error, $transition$.options(), $transition$);
+                    if (!evt.defaultPrevented) {
+                        $urlRouter.update();
+                    }
+                });
+            }
+        }
+        stateNotFoundHandler.$inject = ['$to$', '$from$', '$state', '$rootScope', '$urlRouter'];
+        function stateNotFoundHandler($to$, $from$, injector) {
+            var $state = injector.get('$state');
+            var $rootScope = injector.get('$rootScope');
+            var $urlRouter = injector.get('$urlRouter');
+            var redirect = { to: $to$.identifier(), toParams: $to$.params(), options: $to$.options() };
+            var e = $rootScope.$broadcast('$stateNotFound', redirect, $from$.state(), $from$.params());
+            if (e.defaultPrevented || e.retry)
+                $urlRouter.update();
+            function redirectFn() {
+                return $state.target(redirect.to, redirect.toParams, redirect.options);
+            }
+            if (e.defaultPrevented) {
+                return false;
+            }
+            else if (e.retry || !!$state.get(redirect.to)) {
+                return e.retry && isFunction(e.retry.then) ? e.retry.then(redirectFn) : redirectFn();
+            }
+        }
+        $StateEventsProvider.$inject = ['$stateProvider'];
+        function $StateEventsProvider($stateProvider) {
+            $StateEventsProvider.prototype.instance = this;
+            var runtime = false;
+            var allEvents = ['$stateChangeStart', '$stateNotFound', '$stateChangeSuccess', '$stateChangeError'];
+            var enabledStateEvents = allEvents.map(function (e) { return [e, true]; }).reduce(applyPairs, {});
+            function assertNotRuntime() {
+                if (runtime)
+                    throw new Error('Cannot enable events at runtime (use $stateEventsProvider');
+            }
+            /**
+             * Enables the deprecated UI-Router 0.2.x State Events
+             * [ '$stateChangeStart', '$stateNotFound', '$stateChangeSuccess', '$stateChangeError' ]
+             */
+            this.enable = function () {
+                var events = [];
+                for (var _i = 0; _i < arguments.length; _i++) {
+                    events[_i] = arguments[_i];
+                }
+                assertNotRuntime();
+                if (!events || !events.length)
+                    events = allEvents;
+                events.forEach(function (event) { return (enabledStateEvents[event] = true); });
+            };
+            /**
+             * Disables the deprecated UI-Router 0.2.x State Events
+             * [ '$stateChangeStart', '$stateNotFound', '$stateChangeSuccess', '$stateChangeError' ]
+             */
+            this.disable = function () {
+                var events = [];
+                for (var _i = 0; _i < arguments.length; _i++) {
+                    events[_i] = arguments[_i];
+                }
+                assertNotRuntime();
+                if (!events || !events.length)
+                    events = allEvents;
+                events.forEach(function (event) { return delete enabledStateEvents[event]; });
+            };
+            this.enabled = function () { return enabledStateEvents; };
+            this.$get = $get;
+            $get.$inject = ['$transitions'];
+            function $get($transitions) {
+                runtime = true;
+                if (enabledStateEvents['$stateNotFound'])
+                    $stateProvider.onInvalid(stateNotFoundHandler);
+                if (enabledStateEvents.$stateChangeStart)
+                    $transitions.onBefore({}, stateChangeStartHandler, { priority: 1000 });
+                return {
+                    provider: $StateEventsProvider.prototype.instance,
+                };
+            }
+        }
+        ng
+            .module('ui.router.state.events', ['ui.router.state'])
+            .provider('$stateEvents', $StateEventsProvider)
+            .run([
+            '$stateEvents',
+            function ($stateEvents) {
+                /* Invokes $get() */
+            },
+        ]);
+    })();
+
+    exports.$stateChangeCancel = $stateChangeCancel;
+    exports.$stateChangeError = $stateChangeError;
+    exports.$stateChangeStart = $stateChangeStart;
+    exports.$stateChangeSuccess = $stateChangeSuccess;
+    exports.$stateNotFound = $stateNotFound;
+
+    Object.defineProperty(exports, '__esModule', { value: true });
+
+})));
+//# sourceMappingURL=stateEvents.js.map