logger.debug("Release instance: %s", rel)

          if isinstance(rel, fedfind.release.Pungi4Release):

              if not rel.status in fedfind.const.PUNGI_SUCCESS:

          logger.info("Finding images for: %s %s", rel.dist, rel.version)

      except fedfind.exceptions.CidMatchError as err:

                                                      args.composeid))

      except fedfind.exceptions.UnsupportedComposeError as err:

      except ValueError as err:

      if args.generic_url:

          print(rel.https_url_generic)

          sys.exit()

          super(UrlMatchError, self).__init__()

      def __str__(self):

          return tmpl.format(self.url, self.release.__class__.__name__, self.release.location)

          super(CidMatchError, self).__init__()

      def __str__(self):

          return tmpl.format(self.cid, self.release.__class__.__name__, self.release.cid)

  # vim: set textwidth=100 ts=8 et sw=4:

      if not os.path.exists(CACHEDIR):

          os.makedirs(CACHEDIR)

      if not os.access(CACHEDIR, os.W_OK):

  except (IOError, OSError) as err:

      logger.warning("Cannot use permanent cache! Using temporary cache, valid only for process")

      logger.warning("Error: %s", err)

              dateobj = datetime.datetime.strptime(str(value), '%Y%m%d')

          except ValueError:

              if fail_raise:

                  raise ValueError(newerr)

              else:

                  return False

              logger.debug("Error: %s", err)

              tries -= 1

      if not resp:

      return resp

  def download_json(url):

          except (ValueError, URLError, HTTPError):

              return False

      else:

  def get_size(url):

      """Get the size of URL (Content-Length header for HTTP). Currently

          if '-' in typ and typ.replace('-', '.') in filename:

              return typ

          # Others are more token-y.

              return typ

      # Sometimes we have to be a bit more relaxed.

      for typ in types:

      # Normalize and check cid

      cid = find_cid(origcid)

      if not cid:

                           "compose ID!".format(origcid))

      # Writing a truly generic compose ID parser is pretty tricky. See

      # https://github.com/release-engineering/productmd/issues/77

      specify. Uses PDC.

      """

      short = short.lower()

      res = pdc_query('composes', params)

      if res:

          return res[0]['compose_id']

      # Determine the URL

      if flist not in ('fedora', 'alt', 'archive'):

          raise ValueError("_get_filelist: must be fedora, archive or alt!")

      url = '/'.join((fedfind.const.HTTPS_DL, flist, fname))

      logger.debug("_get_filelist: url is %s", url)

          modified = resp.headers['last-modified']

      except ValueError:

          if cachefh:

              if record:

                  record['downfail'] = True

                  record['cache'] = True

          if dist not in ("FedoraRespin", "Fedora"):

              raise fedfind.exceptions.UnsupportedComposeError(

                  "get_release(): fedfind does not support composes "

      # Atomic stable nightly composes, 'Fedora-Atomic' shortname

      if dist == 'Fedora-Atomic':

              return (dist, release, '', '', 0)

          return (dist, release, 'Production', date, int(respin))

      else:

  def _parse_url(url):

      """Handle a URL if specified. If this looks like the URL for

      # Pungi 4

  #        if int(release) > 23:

  #            return Pungi4Mirror(

      if int(release) < 7:

          return CoreRelease(release)

          else:

              # this should very rarely happen, but we can't reasonably

              # know what to do if it does

                               'be sure what was meant.'.format(dist, milestone))

      return (dist, milestone)

              if url.startswith(fedfind.const.KNOWN_PREFIXES):

                  return Pungi4Release(url)

              else:

                      url, ' '.join(fedfind.const.KNOWN_PREFIXES)))

      elif cid:

          (dist, release, milestone, compose, respin) = _parse_cid(cid)

          # Production - the location for the compose on the unmirrored

          # kojipkgs server

          if not label:

          if not cid:

              # We may actually have a compose ID already on one path:

              # if the user called us with a compose ID and promote=True

              (dist, release, milestone, compose, respin) = _parse_cid(cid)

              return Production(release, compose, respin)

          else:

      # At this point we've handled all composes that we can. If compose

      # is still set, this has to be an error.

          self.compose = str(compose).upper()

          self.version = self.release

          if self.milestone:

          if self.compose:

          try:

              if self.respin:

          except AttributeError:

              # some classes have no respin

              pass

          self.dist = "Fedora"

      def __repr__(self):

              self.__class__, self.release, self.milestone, self.compose)

      def __str__(self):

      @abc.abstractproperty

      def previous_release(self):

                      # add a URL key (save consumers having to do this

                      # work themselves)

                      if imgdict.get('alt', False):

                      else:

                      # add a direct_url key, again for consumer ease

                      if imgdict['url'].startswith(fedfind.const.HTTPS):

                          imgdict['direct_url'] = imgdict['url'].replace(

          if self._relnum < 17:

              split = False

          if self._relnum > 23:

          elif self._relnum > 6:

          elif self._relnum > 4:

          else:

          if split:

              for i in initials:

                  index = fedfind.helpers.urlopen_retries(suburl)

                  text += index.read().decode('utf-8')

          else:

          self._pdccid = ""

      def __repr__(self):

      def __str__(self):

      @property

      def location(self):

      @cached_property

      def https_url_generic(self):

          """Everything tree is 'generic' for Pungi 4."""

      @property

      def status(self):

              return self._metadata

          elif self.exists:

              try:

                  metadata['composeinfo'] = fedfind.helpers.download_json(url)

                  metadata['images'] = fedfind.helpers.download_json(url)

                  if done:

                      self._metadata = metadata

                  if not self._pdccid:

                      # intentionally trigger except block

                      raise ValueError("no pdccid")

                  # we should also be able to retrieve the original

                  # composeinfo dict, but I can't find that at all...

              except ValueError:

          """

          if self._version:

              return self._version

          return self.cid.split(distsep)[1]

      @property

          try:

              idx = complist.index(self.cid)

          except IndexError:

          if idx == 0:

          return get_release(cid=complist[idx-1])

      def get_package_nevras_pdc(self, packages):

          verdict = dict((package, '') for package in packages)

          params = [('compose', self.cid), ('arch', 'src')]

          for package in packages:

          res = fedfind.helpers.pdc_query('rpms', params)

          if not res:

              logger.warning("get_package_nevras_pdc: No results found in PDC for compose %s! "

              # productmd ComposeInfo class has a create_compose_id,

              # but it seems like more work to jump through the hoops

              # to instantiate that than it is to reproduce it...

              # we use get_release_cid not self.__class__ because the

              # params are different for the children classes

              test = get_release(cid=testcid)

                  return test

          logger.setLevel(loglevel)

          raise ValueError("Could not find previous compose for "

  class RawhideNightly(OldPreviousReleaseMixin, Pungi4Release):

      def __init__(self, compose, respin=0, cid=None):

          compose = str(compose)

          respin = str(respin)

          url = '/'.join((fedfind.const.NIGHTLY_BASE, path))

          super(RawhideNightly, self).__init__(url, release="Rawhide", milestone='', compose=compose,

                                               respin=respin, typ="nightly", cid=cid)

      def __init__(self, compose, respin=0, cid=None):

          compose = str(compose)

          respin = str(respin)

          url = '/'.join((fedfind.const.NIGHTLY_BASE, path))

          super(RawhideModularNightly, self).__init__(

              url, release="Rawhide", milestone='', compose=compose,

          """Server tree is 'generic' for modular composes at present,

          there is no Everything tree.

          """

  class BikeshedModularNightly(Pungi4Release):

      def __init__(self, compose, respin=0, cid=None):

          compose = str(compose)

          respin = str(respin)

          url = '/'.join((fedfind.const.NIGHTLY_BASE, path))

          super(BikeshedModularNightly, self).__init__(

              url, release="Bikeshed", milestone='', compose=compose,

          """Server tree is 'generic' for modular composes at present,

          there is no Everything tree.

          """

  class BranchedNightly(OldPreviousReleaseMixin, Pungi4Release):

          release = str(release)

          compose = str(compose)

          respin = str(respin)

          url = '/'.join((fedfind.const.NIGHTLY_BASE, path))

          super(BranchedNightly, self).__init__(

              url, release=release, milestone="Branched", compose=compose,

          release = str(release)

          compose = str(compose)

          respin = str(respin)

          url = '/'.join((fedfind.const.NIGHTLY_BASE, path))

          super(BranchedModularNightly, self).__init__(

              url, release=release, milestone="Branched", compose=compose,

          release = str(release)

          compose = str(compose)

          respin = str(respin)

          url = '/'.join((fedfind.const.NIGHTLY_BASE, path))

          super(AtomicNightly, self).__init__(

              url, release=release, milestone="Nightly", compose=compose,

          release = str(release)

          compose = str(compose)

          respin = str(respin)

          url = '/'.join((fedfind.const.NIGHTLY_BASE, path))

          super(CloudNightly, self).__init__(

              url, release=release, milestone="Nightly", compose=compose,

          release = str(release)

          compose = str(compose)

          respin = str(respin)

          url = '/'.join((fedfind.const.NIGHTLY_BASE, path))

          super(DockerNightly, self).__init__(

              url, release=release, milestone="Nightly", compose=compose,

          release = str(release)

          compose = str(compose)

          respin = str(respin)

          url = '/'.join((fedfind.const.NIGHTLY_BASE, path))

          super(ContainerNightly, self).__init__(

              url, release=release, milestone="Nightly", compose=compose,

          release = str(release)

          compose = str(compose)

          respin = str(respin)

          url = '/'.join((fedfind.const.NIGHTLY_BASE, path))

          super(IoTNightly, self).__init__(

              url, release=release, milestone="Nightly", compose=compose,

          release = str(release)

          compose = str(compose)

          respin = str(respin)

          url = '/'.join((fedfind.const.NIGHTLY_BASE, path))

          super(Updates, self).__init__(

              url, release=release, milestone="Updates", compose=compose,

          release = str(release)

          compose = str(compose)

          respin = str(respin)

          url = '/'.join((fedfind.const.NIGHTLY_BASE, path))

          super(UpdatesTesting, self).__init__(

              url, release=release, milestone="Updates-testing", compose=compose,

          _version in init as that would cause remote trips, do it here

          as a property.

          """

  class ModularProduction(Pungi4Release):

          _version in init as that would cause remote trips, do it here

          as a property.

          """

              self.release, self.milestone, self.compose, self.respin)

          milestone = str(milestone)

          compose = str(compose)

          respin = str(respin)

          super(Compose, self).__init__(

              url, release=release, milestone=milestone, compose=compose,

              respin=respin, label=label, typ="production", version=version, cid=cid)

          milestone = str(milestone)

          compose = str(compose)

          respin = str(respin)

          super(ModularCompose, self).__init__(

              url, release=release, milestone=milestone, compose=compose,

              respin=respin, label=label, typ="production", version=version, cid=cid)

      """

      def __init__(self, path, **kwargs):

          self._basepath = path.rstrip('/')

      def __repr__(self):

      def __str__(self):

      @property

      def _checkloc(self):

          # property if we can't find a real one. We store it on the

          # instance so methods can check if we have a real or fake one

          # by doing 'self.cid == self._fakecid".

      @abc.abstractproperty

      def _basepath(self):

              return self._exists

          url = self.https_url_generic.replace(fedfind.const.HTTPS, fedfind.const.HTTPS_DL)

          if not url:

          logger.debug("exists: checking URL %s", url)

          if fedfind.helpers.url_exists(url):

              self._exists = True

          Used for constructing image paths, etc.

          """

          if self._prefurl == "direct":

          else:

      @property

      def alt_location(self):

          Used for constructing image paths, etc.

          """

          if self._prefurl == "direct":

          else:

      @property

      def https_url_generic(self):

          if self._relnum < 7:

              return self.location

          elif self._relnum < 21:

          elif self._relnum <= 23:

          else:

      @property

      def metadata(self):

              # We can try to get the real metadata from PDC and just

              # tweak it a bit.

              try:

                  # we should also be able to retrieve the original

                  # composeinfo dict, but I can't find that at all...

              except ValueError:

              relname = '_'.join((self.release, self.milestone))

          else:

              relname = self.release

          for (_, path) in self.all_paths:

              fname = path.split('/')[-1]

              match = exp.search(fname)

      @property

      def _basepath(self):

      @property

      def _altbasepath(self):

  ## STABLE RELEASE CLASSES ##

      @property

      def _basepath(self):

      @property

      def _altbasepath(self):

  class ArchiveRelease(MirrorRelease):

      @property

      def _basepath(self):

      @property

      def _altbasepath(self):

          if self._relnum > 14:

          else:

              # there were no 'alt' bits prior to F15

              return None

      @property

      def _basepath(self):

      @property

      def _altbasepath(self):

                  "Could not determine release and compose for current respin release!")

          if release and release != gotrelease:

              raise fedfind.exceptions.DiscoveryError(

          if compose and compose != gotcompose:

              raise fedfind.exceptions.DiscoveryError(

          super(RespinRelease, self).__init__(gotrelease, milestone, gotcompose)

          # if we got this far, we already know we exist

          self._exists = True

          # custom fake CID for these releases

      def __repr__(self):

      @property

      def _basepath(self):

      """

      root = os.path.join(os.path.dirname(os.path.realpath(__file__)),

                          'data', 'http')

      # block until the server is actually running

      resp = None

      while not resp:

          try:

              resp = urlopen('http://localhost:5001/pub')

          except (ValueError, URLError, HTTPError):

              time.sleep(0.1)

      # Redefine the HTTPS_DL and HTTPS constants to point to the fake

      fedfind.const.HTTPS_DL = 'http://localhost:5001/pub'

      fedfind.const.HTTPS = 'http://localhost:5001/pub'

  @pytest.fixture(scope="function")

  def clean_home(request):

          shutil.rmtree(home)

      cachedir = os.path.join(home, '.cache', 'fedfind')

      os.makedirs(cachedir)

  def fake_pdc_query(path, params=None):

      """A fake pdc_query that doesn't really hit PDC, it just returns

      match = compimgs.match(path)

      if match:

          fname = os.path.join(os.path.dirname(os.path.realpath(__file__)),

          with open(fname, 'r') as datafh:

              return json.loads(datafh.read())

  @pytest.fixture(scope="function")

  def pdc(request):

      """Mock fedfind.helpers.pdc_query with fake_pdc_query."""

  @pytest.fixture(scope="function")

  def collections(request):

      """Mock fedfind.helpers._get_collections to return test data."""

  @pytest.fixture(scope="function")

  def json_collections(request):

      data (wrapped appropriately). Returns the mock so tests can check

      its call count, and the test data so they can verify it.

      """

  # vim: set textwidth=100 ts=8 et sw=4:

          def check_file(flist, touch=False):

              """Inner function for doing the check (run multiple times)"""

              origfile = os.path.join(os.path.dirname(os.path.realpath(__file__)), 'data', 'http',

              if touch:

                  os.utime(origfile, None)

              gotcksum = hashlib.md5()

              record = {}