Distribution.h

Go to the documentation of this file.

/*
 *  BEEN: Benchmarking Environment
 *  ==============================
 *
 *  File author: Branislav Repcek
 *
 *  GNU Lesser General Public License Version 2.1
 *  ---------------------------------------------
 *  Copyright (C) 2004-2006 Distributed Systems Research Group,
 *  Faculty of Mathematics and Physics, Charles University in Prague
 *
 *  This library is free software; you can redistribute it and/or
 *  modify it under the terms of the GNU Lesser General Public
 *  License version 2.1, as published by the Free Software Foundation.
 *
 *  This library is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 *  Lesser General Public License for more details.
 *
 *  You should have received a copy of the GNU Lesser General Public
 *  License along with this library; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place, Suite 330, Boston,
 *  MA  02111-1307  USA
 */

#ifndef DISTRIBUTION_INCLUDED
#define DISTRIBUTION_INCLUDED

#include <stdio.h>
#include <sys/utsname.h>
#include "../common/UnicodeString.h"
#include "../common/XMLFileOutput.h"
#include "../common/MessageReporter.h"
#include "Packager.h"
#include "DefaultPackager.h"

#define AUTO_FREE_PACKAGERS 1

#define KERNEL_VERSION_CODE(major, minor, release) (0x10000 * (major) + 0x100 * (minor) + (release))

namespace hwdet
{
    class Distribution : public MessageReporter
    {
    public:
        Distribution(const String &distro_name, MessageReporter *parent_reporter) :
        MessageReporter(distro_name, parent_reporter),
        kernel_major(0),
        kernel_minor(0),
        kernel_release(0),
        kernel_version_code(0),
        uts_name(TXT("(unknown)")),
        uts_release(TXT("(unknown)")),
        uts_version(TXT("(unknown)")),
        uts_machine(TXT("(unknown)")),
        kernel_version_parsed(TXT("(unknown)")),
        default_packager(new DefaultPackager(this))
        {
            utsname uts;
        
            if (uname(&uts) == -1)
            {
                // Call failed -> exit.
                return;
            }
        
            if (sscanf(uts.release, "%d.%d.%d", &kernel_major, &kernel_minor, &kernel_release) < 3)
            {
                // Unable to parse all three fields.
                kernel_major = kernel_minor = kernel_release = kernel_version_code = 0;
            }
            else
            {
                kernel_version_code = KERNEL_VERSION_CODE(kernel_major, kernel_minor, kernel_release);
                uts_name = String(uts.sysname);
                uts_release = String(uts.release);
                uts_version = String(uts.version);
                uts_machine = String(uts.machine);
                
                StringStream stream;
                stream << kernel_major << TXT(".") << kernel_minor << TXT(".") << kernel_release;
                
                kernel_version_parsed = stream.str();
            }
        }
        
        virtual ~Distribution(void)
        {
#if AUTO_FREE_PACKAGERS != 0
            for (std::vector< Packager * >::iterator it = packagers.begin(); 
                 it != packagers.end();
                 ++it)
            {
                delete *it;
            }
#endif
            delete default_packager;
        }
        
        String GetName(void) const
        {
            return GetName();
        }
        
        virtual float GetFitness(void) = 0;
        
        virtual bool DetectOS(XMLElement *root_node) = 0;
        
        virtual bool DetectSoftware(XMLElement *products_node)
        {
            if (!products_node)
            {
                ReportMessage("Invalid products node.");
                return false;
            }
            
            Packager *current_packager = GetPackager();
            
            return current_packager->DetectSoftware(products_node);
        }
        
        void AddPackager(Packager *packager)
        {
            if (packager)
            {
                packagers.push_back(packager);
            }
        }
                
        Packager *GetPackager(void)
        {
            // Find first match.
            for (std::vector< Packager * >::iterator it = packagers.begin();
                 it != packagers.end();
                 ++it)
            {
                if ((*it)->IsSupported())
                {
                    return *it;
                }
            }
            
            // No match found, return default packager.
            return default_packager;
        }
        
    protected:
        int kernel_major;
        
        int kernel_minor;
        
        int kernel_release;
        
        int kernel_version_code;
        
        String uts_name;
        
        String uts_release;
        
        String uts_version;
        
        String uts_machine;
        
        String kernel_version_parsed;
        
    private:
        std::vector< Packager * > packagers;
        
        DefaultPackager           *default_packager;
    };
}

#endif

---