Remove license code in Quay

No longer needed under Red Hat rules \o/

Fixes https://jira.coreos.com/browse/QUAY-883

util/config/provider/baseprovider.py

@@ -1,13 +1,9 @@
 import logging
 import yaml
 
-
 from jsonschema import validate, ValidationError
 
-
 from util.config.schema import CONFIG_SCHEMA
-from util.license import LICENSE_FILENAME, LicenseDecodeError, decode_license
-
 
 logger = logging.getLogger(__name__)
 
@@ -63,8 +59,6 @@ def export_yaml(config_obj, config_file):
 class BaseProvider(object):
   """ A configuration provider helps to load, save, and handle config override in the application.
   """
-  def __init__(self):
-    self.license = None
 
   @property
   def provider_id(self):
@@ -128,30 +122,3 @@ class BaseProvider(object):
     """ Helper for constructing file paths, which may differ between providers. For example,
     kubernetes can't have subfolders in configmaps """
     raise NotImplementedError
-
-  def _get_license_file(self):
-    """ Returns the contents of the license file. """
-    if not self.has_license_file():
-     msg = 'Could not find license file. Please make sure it is in your config volume.'
-     raise LicenseDecodeError(msg)
-
-    try:
-      return self.get_volume_file(LICENSE_FILENAME)
-    except IOError:
-      msg = 'Could not open license file. Please make sure it is in your config volume.'
-      raise LicenseDecodeError(msg)
-
-  def get_license(self):
-    """ Returns the decoded license, if any. """
-    with self._get_license_file() as f:
-      license_file_contents = f.read()
-
-    return decode_license(license_file_contents)
-
-  def save_license(self, license_file_contents):
-    """ Saves the given contents as the license file. """
-    self.write_volume_file(LICENSE_FILENAME, license_file_contents)
-
-  def has_license_file(self):
-    """ Returns true if a license file was found in the config directory. """
-    return self.volume_file_exists(LICENSE_FILENAME)

util/config/provider/testprovider.py

@@ -4,21 +4,9 @@ import os
 from datetime import datetime, timedelta
 
 from util.config.provider.baseprovider import BaseProvider
-from util.license import (EntitlementValidationResult, Entitlement, Expiration, ExpirationType,
-                          EntitlementRequirement)
 
 REAL_FILES = ['test/data/signing-private.gpg', 'test/data/signing-public.gpg', 'test/data/test.pem']
 
-class TestLicense(object):
-  def validate_entitlement_requirement(self, entitlement_req, check_time):
-    expiration = Expiration(ExpirationType.license_wide, datetime.now() + timedelta(days=31))
-    entitlement = Entitlement('fake', 0, 'someprod', expiration)
-    fakereq = EntitlementRequirement('fake', 0)
-    return EntitlementValidationResult(fakereq, datetime.now(), entitlement)
-
-  def validate(self, config):
-    return [self.validate_entitlement_requirement(None, None)]
-
 class TestConfigProvider(BaseProvider):
   """ Implementation of the config provider for testing. Everything is kept in-memory instead on
       the real file system. """
@@ -82,10 +70,7 @@ class TestConfigProvider(BaseProvider):
 
   def requires_restart(self, app_config):
     return False
-
-  def get_license(self):
-    return TestLicense()
-
+    
   def reset_for_test(self):
     self._config['SUPER_USERS'] = ['devtable']
     self.files = {}

util/config/validator.py

@@ -3,7 +3,6 @@ import logging
 from auth.auth_context import get_authenticated_user
 from data.users import LDAP_CERT_FILENAME
 
-from util.config.validators.validate_license import LicenseValidator
 from util.config.validators.validate_database import DatabaseValidator
 from util.config.validators.validate_redis import RedisValidator
 from util.config.validators.validate_storage import StorageValidator
@@ -42,7 +41,6 @@ CONFIG_FILE_SUFFIXES = ['-cloudfront-signing-key.pem']
 EXTRA_CA_DIRECTORY = 'extra_ca_certs'
 
 VALIDATORS = {
-  LicenseValidator.name: LicenseValidator.validate,
   DatabaseValidator.name: DatabaseValidator.validate,
   RedisValidator.name: RedisValidator.validate,
   StorageValidator.name: StorageValidator.validate,

util/config/validators/test/test_validate_license.py

@@ -1,48 +0,0 @@
-import pytest
-
-from mock import patch
-
-from util.config.validators import ConfigValidationException
-from util.config.validators.validate_license import LicenseValidator
-from util.morecollections import AttrDict
-from util.license import License, QUAY_DEPLOYMENTS_ENTITLEMENT, QUAY_ENTITLEMENT
-
-from test.fixtures import *
-
-@pytest.mark.parametrize('deployments, allowed_deployments', [
-  (1, 1),
-  (3, 3),
-  (3, 2),
-  (3, 1),
-])
-def test_too_many_storage_engines(deployments, allowed_deployments, app):
-  def get_license():
-    decoded = {
-      'expirationDate': '2157-12-1',
-      'subscriptions': {
-        'someSubscription': {
-          'serviceEnd': '2157-12-1',
-          'durationPeriod': 'yearly',
-          'entitlements': {
-            QUAY_ENTITLEMENT: 1,
-            QUAY_DEPLOYMENTS_ENTITLEMENT: allowed_deployments,
-          },
-        },
-      },
-    }
-    return License(decoded)
-
-  storage_configs = [(str(i), {}) for i in range(0, deployments)]
-
-  with patch('app.config_provider.get_license', get_license):
-    validator = LicenseValidator()
-
-    if allowed_deployments < deployments:
-      with pytest.raises(ConfigValidationException):
-        validator.validate({
-          'DISTRIBUTED_STORAGE_CONFIG': storage_configs,
-        }, None, None)
-    else:
-      validator.validate({
-        'DISTRIBUTED_STORAGE_CONFIG': storage_configs,
-      }, None, None)

util/config/validators/validate_license.py

@@ -1,19 +0,0 @@
-from app import config_provider
-from util.config.validators import BaseValidator, ConfigValidationException
-from util.license import LicenseDecodeError, EntitlementStatus
-
-class LicenseValidator(BaseValidator):
-  name = "license"
-
-  @classmethod
-  def validate(cls, config, user, user_password):
-    try:
-      decoded_license = config_provider.get_license()
-    except LicenseDecodeError as le:
-      raise ConfigValidationException('Could not decode license: %s' % le.message)
-
-    results = decoded_license.validate(config)
-    all_met = all(result.is_met() for result in results)
-    if not all_met:
-      reason = [result.description() for result in results if not result.is_met()]
-      raise ConfigValidationException('License does not match configuration: %s' % reason)