YUMPrimaryParser.cc

Go to the documentation of this file.

/*---------------------------------------------------------------------\
|                          ____ _   __ __ ___                          |
|                         |__  / \ / / . \ . \                         |
|                           / / \ V /|  _/  _/                         |
|                          / /__ | | | | | |                           |
|                         /_____||_| |_| |_|                           |
|                                                                      |
\---------------------------------------------------------------------*/
#include <zypp/parser/yum/YUMPrimaryParser.h>
#include <istream>
#include <string>
#include "zypp/parser/xml_parser_assert.h"
#include <libxml/xmlstring.h>
#include <libxml/xmlreader.h>
#include <libxml/tree.h>
#include <zypp/parser/LibXMLHelper.h>
#include <zypp/base/Logger.h>
#include <zypp/parser/yum/schemanames.h>
#include <zypp/ZYppFactory.h>

using namespace std;
namespace zypp
{
namespace parser
{
namespace yum
{


YUMPrimaryParser::YUMPrimaryParser(std::istream &is, const std::string& baseUrl, parser::ParserProgress::Ptr progress )
    : XMLNodeIterator<YUMPrimaryData_Ptr>(is, baseUrl,PRIMARYSCHEMA, progress)
    , _zypp_architecture( getZYpp()->architecture() )
{
  if (is.fail())
  {
    ERR << "Bad stream" << endl;
  }
  fetchNext();
}

YUMPrimaryParser::YUMPrimaryParser(const Pathname &filename, const std::string &baseUrl, parser::ParserProgress::Ptr progress )
    : XMLNodeIterator<YUMPrimaryData_Ptr>(filename, baseUrl,PRIMARYSCHEMA, progress)
    , _zypp_architecture( getZYpp()->architecture() )
{
  fetchNext();
}

YUMPrimaryParser::YUMPrimaryParser()
    : _zypp_architecture( getZYpp()->architecture() )
{ }

YUMPrimaryParser::YUMPrimaryParser(YUMPrimaryData_Ptr& entry)
    : XMLNodeIterator<YUMPrimaryData_Ptr>(entry)
    , _zypp_architecture( getZYpp()->architecture() )
{ }


YUMPrimaryParser::~YUMPrimaryParser()
{}




// select for which elements process() will be called
bool
YUMPrimaryParser::isInterested(const xmlNodePtr nodePtr)
{
  bool result = (_helper.isElement(nodePtr)
                 && _helper.name(nodePtr) == "package");
  return result;
}


// do the actual processing
YUMPrimaryData_Ptr
YUMPrimaryParser::process(const xmlTextReaderPtr reader)
{
  xml_assert(reader);
  YUMPrimaryData_Ptr dataPtr = new YUMPrimaryData;
  xmlNodePtr dataNode = xmlTextReaderExpand(reader);
  xml_assert(dataNode);

  dataPtr->type = _helper.attribute(dataNode,"type");
  dataPtr->installOnly = false;
  dataPtr->media = "1";

  for (xmlNodePtr child = dataNode->children;
       child != 0;
       child = child->next)
  {
    if (_helper.isElement(child))
    {
      string name = _helper.name(child);
      if (name == "name")
      {
        dataPtr->name = _helper.content(child);
      }
      else if (name == "arch")
      {
        dataPtr->arch = _helper.content(child);
        try
        {
          if (!Arch(dataPtr->arch).compatibleWith( _zypp_architecture ))
          {
            dataPtr = NULL;                     // skip <package>, incompatible architecture
            break;
          }
        }
        catch ( const Exception & excpt_r )
        {
          ZYPP_CAUGHT( excpt_r );
          DBG << "Skipping malformed " << dataPtr->arch << endl;
          dataPtr = NULL;
          break;
        }
      }
      else if (name == "version")
      {
        dataPtr->epoch = _helper.attribute(child,"epoch");
        dataPtr->ver = _helper.attribute(child,"ver");
        dataPtr->rel = _helper.attribute(child,"rel");
      }
      else if (name == "checksum")
      {
        dataPtr->checksumType = _helper.attribute(child,"type");
        dataPtr->checksumPkgid = _helper.attribute(child,"pkgid");
        dataPtr->checksum = _helper.content(child);
      }
      else if (name == "summary")
      {
        dataPtr->summary = _helper.content(child);
      }
      else if (name == "description")
      {
        dataPtr->description = _helper.content(child);
      }
      else if (name == "packager")
      {
        dataPtr->packager = _helper.content(child);
      }
      else if (name == "url")
      {
        dataPtr->url = _helper.content(child);
      }
      else if (name == "time")
      {
        dataPtr->timeFile = _helper.attribute(child,"file");
        dataPtr->timeBuild = _helper.attribute(child,"build");
      }
      else if (name == "size")
      {
        dataPtr->sizePackage = _helper.attribute(child,"package");
        dataPtr->sizeInstalled = _helper.attribute(child,"installed");
        dataPtr->sizeArchive = _helper.attribute(child,"archive");
      }
      else if (name == "location")
      {
        dataPtr->location = _helper.attribute(child,"href");
        dataPtr->media = _helper.attribute(child,"base","#1");
        int pos = dataPtr->media.find("#");
        if (pos > 0)
          dataPtr->media = dataPtr->media.substr(pos + 1);
      }
      else if (name == "format")
      {
        parseFormatNode(dataPtr, child);
      }
      else if (name == "license-to-confirm")
      {
        dataPtr->license_to_confirm.setText(_helper.content(child), Locale(_helper.attribute(child,"lang")));
      }
      else
      {
        WAR << "YUM <metadata> contains the unknown element <" << name << "> "
        << _helper.positionInfo(child) << ", skipping" << endl;
      }
    }
  }
  return dataPtr;
} /* end process */



void
YUMPrimaryParser::parseFormatNode(YUMPrimaryData_Ptr dataPtr,
                                  xmlNodePtr formatNode)
{
  if (dataPtr == NULL) return;                  // skipping
  xml_assert(formatNode);
  dataPtr->installOnly = false;
  for (xmlNodePtr child = formatNode->children;
       child != 0;
       child = child ->next)
  {
    if (_helper.isElement(child))
    {
      string name = _helper.name(child);
      if (name == "license")
      {
        dataPtr->license = _helper.content(child);
      }
      else if (name == "vendor")
      {
        dataPtr->vendor = _helper.content(child);
      }
      else if (name == "group")
      {
        dataPtr->group = _helper.content(child);
      }
      else if (name == "buildhost")
      {
        dataPtr->buildhost = _helper.content(child);
      }
      else if (name == "sourcerpm")
      {
        dataPtr->sourcerpm = _helper.content(child);
      }
      else if (name == "header-range")
      {
        dataPtr->headerStart = _helper.attribute(child,"start");
        dataPtr->headerEnd = _helper.attribute(child,"end");
      }
      else if (name == "provides")
      {
        parseDependencyEntries(& dataPtr->provides, child);
      }
      else if (name == "conflicts")
      {
        parseDependencyEntries(& dataPtr->conflicts, child);
      }
      else if (name == "obsoletes")
      {
        parseDependencyEntries(& dataPtr->obsoletes, child);
      }
      else if (name == "prerequires")
      {
        parseDependencyEntries(& dataPtr->prerequires, child);
      }
      else if (name == "requires")
      {
        parseDependencyEntries(& dataPtr->requires, child);
      }
      else if (name == "recommends")
      {
        parseDependencyEntries(& dataPtr->recommends, child);
      }
      else if (name == "suggests")
      {
        parseDependencyEntries(& dataPtr->suggests, child);
      }
      else if (name == "supplements")
      {
        parseDependencyEntries(& dataPtr->supplements, child);
      }
      else if (name == "enhances")
      {
        parseDependencyEntries(& dataPtr->enhances, child);
      }
      else if (name == "file")
      {
        dataPtr->files.push_back
        (FileData(_helper.content(child),
                  _helper.attribute(child,"type")));
      }
      /* SUSE specific elements */
      else if (name == "authors")
      {
        parseAuthorEntries(& dataPtr->authors, child);
      }
      else if (name == "keywords")
      {
        parseKeywordEntries(& dataPtr->keywords, child);
      }
      else if (name == "dirsizes")
      {
        parseDirsizeEntries(& dataPtr->dirSizes, child);
      }
      else if (name == "freshens")
      {
        parseDependencyEntries(& dataPtr->freshens, child);
      }
      else if (name == "install-only")
      {
        dataPtr->installOnly = true;
      }
      else if (name == "license-to-confirm")
      {
        dataPtr->license_to_confirm.setText(_helper.content(child), Locale(_helper.attribute(child,"lang")));
      }
      else
      {
        WAR << "YUM <format> contains the unknown element <" << name << "> "
        << _helper.positionInfo(child) << ", skipping" << endl;
      }
    }
  }
}


void
YUMPrimaryParser::parseDependencyEntries(std::list<YUMDependency> *depList,
    xmlNodePtr depNode)
{
  xml_assert(depList);
  xml_assert(depNode);

  for (xmlNodePtr child = depNode->children;
       child != 0;
       child = child ->next)
  {
    if (_helper.isElement(child))
    {
      string name = _helper.name(child);
      // we have 2 format for entries
      // For YUM repositories
      // <entry kind="package" name="foo" epoch="2" ver="3" rel="4" flags="LE"/>
      // The slightly modified YUM format the storage backend uses.
      // <capability kind="package" >foo-devel &lt;= 3:4-5</capability>

      if (name == "entry")
      {
        if ( _helper.content(child).empty() )
        {
          depList->push_back
          (YUMDependency(_helper.attribute(child,"kind"),
                         _helper.attribute(child,"name"),
                         _helper.attribute(child,"flags"),
                         _helper.attribute(child,"epoch"),
                         _helper.attribute(child,"ver"),
                         _helper.attribute(child,"rel"),
                         _helper.attribute(child,"pre")));
        }
        else
        { // only for backward compat, before we renamed the tag to capability
          depList->push_back
          (YUMDependency(_helper.attribute(child,"kind"),
                         _helper.content(child)));
        }
      }
      else if ( name == "capability" )
      {
        depList->push_back
        (YUMDependency(_helper.attribute(child,"kind"),
                       _helper.content(child)));
      }
      else
      {
        WAR << "YUM dependency within <format> contains the unknown element <" << name << "> "
        << _helper.positionInfo(child) << ", skipping" << endl;
      }
    }
  }
}

void
YUMPrimaryParser::parseAuthorEntries(std::list<std::string> *authors,
                                     xmlNodePtr node)
{
  xml_assert(authors);
  xml_assert(node);

  for (xmlNodePtr child = node->children;
       child != 0;
       child = child ->next)
  {
    if (_helper.isElement(child))
    {
      string name = _helper.name(child);
      if (name == "author")
      {
        authors->push_back(_helper.content(child));
      }
      else
      {
        WAR << "YUM <authors> contains the unknown element <" << name << "> "
        << _helper.positionInfo(child) << ", skipping" << endl;
      }
    }
  }
}

void YUMPrimaryParser::parseKeywordEntries(std::list<std::string> *keywords,
    xmlNodePtr node)
{
  xml_assert(keywords);
  xml_assert(node);

  for (xmlNodePtr child = node->children;
       child != 0;
       child = child ->next)
  {
    if (_helper.isElement(child))
    {
      string name = _helper.name(child);
      if (name == "keyword")
      {
        keywords->push_back(_helper.content(child));
      }
      else
      {
        WAR << "YUM <keywords> contains the unknown element <" << name << "> "
        << _helper.positionInfo(child) << ", skipping" << endl;
      }
    }
  }
}

void YUMPrimaryParser::parseDirsizeEntries(std::list<YUMDirSize> *sizes,
    xmlNodePtr node)
{
  xml_assert(sizes);
  xml_assert(node);

  for (xmlNodePtr child = node->children;
       child != 0;
       child = child ->next)
  {
    if (_helper.isElement(child))
    {
      string name = _helper.name(child);
      if (name == "dirsize")
      {
        sizes->push_back(YUMDirSize(_helper.attribute(child,"path"),
                                    _helper.attribute(child,"size-kbyte"),
                                    _helper.attribute(child,"filecount")));
      }
      else
      {
        WAR << "YUM <dirsizes> contains the unknown element <" << name << "> "
        << _helper.positionInfo(child) << ", skipping" << endl;
      }
    }
  }
}

} // namespace yum
} // namespace parser
} // namespace zypp

---