source: lliurex-apt/trunk/fuentes/src/Sources.cpp @ 923

#include "Sources.hpp"

#include <iostream>
#include <fstream>
#include <string>
#include <stdexcept>
#include <sstream>

#include <regex.h>
#include <glibmm/regex.h>
#include <giomm.h>
#include <glibmm.h>

using namespace std;
using namespace net::lliurex::apt;



string SourceLine::ToString()
{
        stringstream ss;
        
        ss.str("");
        ss<< ((source_type==SourceType::Deb) ? "deb" : "deb-src");
        ss<<" ";
        
        switch(uri_type)
        {
                case UriType::Http:
                        ss<<"http://";
                break;
                
                case UriType::Https:
                        ss<<"https://";
                break;
                
                case UriType::Ftp:
                        ss<<"ftp://";
                break;
                
                case UriType::File:
                        ss<<"file://";
                break;
                
                case UriType::Cdrom:
                        ss<<"cdrom:";
                break;
        }
        
        ss<<uri<<" "<<dist;
        
        for(string c : components)
        {
                ss<<" "<<c;
        }
        
        return ss.str();
}

bool SourceLine::IsEqual(SourceLine & line)
{
        bool found=false;
        
        if(source_type==line.source_type && uri_type==line.uri_type
        && uri==line.uri && dist==line.dist)
        {
                found=true;
                
                for(string c : components)
                {
                        bool cfound = false;

                        for(string cc : line.components)
                        {
                                if(cc==c)cfound=true;
                        }

                        if(!cfound)found=false;
                }
        }
        
        return found;
}


string Sources::str_line="^(?<deb_type>deb|deb\\-src)\\s+(?<uri_type>http://|https://|file://|ftp://|cdrom:)(?<uri>\\[.+\\]/|\\S+)\\s+(?<dist>\\S+)(?<components>(\\s+\\S+)+)";
        
string Sources::str_option="^#(?<key>\\w+)(\\[(?<locale>\\S+)\\])?\\s*=\\s*(?<value>.*)";

const string Sources::SourcesList = "/etc/apt/sources.list";


Sources::Sources()
{

}


Sources::Sources(string filename)
{
        
                
        Glib::RefPtr<Glib::Regex> regex_line = Glib::Regex::create(Sources::str_line);
        Glib::RefPtr<Glib::Regex> regex_option = Glib::Regex::create(Sources::str_option);
        
        ifstream file(filename);
        
        
        optional=false;
        name["C"]="noname";
                
        while(!file.eof())
        {
                string line;
                getline(file,line);//read a single line from the file
                
                Glib::MatchInfo info;
                
                //have we got a match?
                if(regex_line->match(line,info))
                {
                        
                        string type;
                        string uri_type;
                        string uri;
                        string dist;
                        string components;
                        vector<string> vcmp;
                        
                        //fetch matching groups
                        type = info.fetch_named("deb_type");
                        uri_type=info.fetch_named("uri_type");
                        uri=info.fetch_named("uri");
                        dist = info.fetch_named("dist");
                                                
                        
                        components=info.fetch_named("components");
                        
                        //split components
                        string buf;
                        stringstream ss(components.substr(1));
                                                                        
                        while(ss >> buf)
                                vcmp.push_back(buf);
                                
                        
                        //fill SourceLine object
                        SourceLine sl;
                        
                        if(type=="deb")sl.source_type=SourceType::Deb;
                        if(type=="deb-src")sl.source_type=SourceType::Source;
                        
                        if(uri_type=="http://")sl.uri_type=UriType::Http;
                        if(uri_type=="https://")sl.uri_type=UriType::Https;
                        if(uri_type=="file://")sl.uri_type=UriType::File;
                        if(uri_type=="ftp://")sl.uri_type=UriType::Ftp;
                        if(uri_type=="cdrom:")sl.uri_type=UriType::Cdrom;
                        
                        
                        //remove all ending slashs
                        while(uri[uri.length()-1]=='/')
                        {
                                uri=uri.substr(0,uri.length()-1);
                        }
                        
                        sl.uri=uri;
                        sl.dist=dist;
                        
                        sl.components = vcmp;
                                                
                        
                        //and Push it up
                        Push(sl);
                }
                else
                {
                        if(regex_option->match(line,info))
                        {
                                
                                string key=info.fetch_named("key");
                                string value=info.fetch_named("value");
                                string locale=info.fetch_named("locale");
                                
                                if(key=="optional")
                                {
                                        optional=(value=="true");
                                }
                                
                                if(key=="name")
                                {
                                        locale=(locale=="") ? "C" : locale;
                                        name[locale]=value;
                                }
                                
                                
                        }
                }
        }
        
        file.close();
}


void Sources::Add(string line)
{
        Glib::RefPtr<Glib::Regex> regex_line = Glib::Regex::create(Sources::str_line);
        
        Glib::MatchInfo info;
                

        if(regex_line->match(line,info))
        {
                string type;
                string uri_type;
                string uri;
                string dist;
                string components;
                vector<string> vcmp;
                
                //fetch matching groups
                type = info.fetch_named("deb_type");
                uri_type=info.fetch_named("uri_type");
                uri=info.fetch_named("uri");
                dist = info.fetch_named("dist");
                
                components=info.fetch_named("components");
                
                //split components
                string buf;
                stringstream ss(components.substr(1));
                                                                
                while(ss >> buf)
                        vcmp.push_back(buf);
                        
                
                //fill SourceLine object
                SourceLine sl;
                
                if(type=="deb")sl.source_type=SourceType::Deb;
                if(type=="deb-src")sl.source_type=SourceType::Source;
                
                if(uri_type=="http://")sl.uri_type=UriType::Http;
                if(uri_type=="https://")sl.uri_type=UriType::Https;
                if(uri_type=="file://")sl.uri_type=UriType::File;
                if(uri_type=="ftp://")sl.uri_type=UriType::Ftp;
                if(uri_type=="cdrom:")sl.uri_type=UriType::Cdrom;
                                        
                sl.uri=uri;
                sl.dist=dist;
                
                sl.components = vcmp;
                                        
                
                //and Push it up
                Push(sl);
        }
        else
        {
                throw runtime_error("Failed to parse source line");
        }
        
}


void Sources::Push(SourceLine line)
{

        bool found = false;
        
        for(int n = 0;n<lines.size();n++)
        {
                SourceLine & q = lines[n];
                
                if(q.source_type==line.source_type && q.uri_type==line.uri_type
                 && q.uri==line.uri && q.dist==line.dist)
                 {
                        found = true;
                        
                        for(string component : line.components)
                        {
                                bool cfound = false;
                                
                                for(string c : q.components)
                                {
                                        if(c==component)cfound=true;
                                }
                                
                                if(!cfound)
                                {
                                        q.components.push_back(component);
                                }
                        }
                 }
        }
        
        if(!found)
        {
                lines.push_back(line);
        }
}


FindLineStatus Sources::Find(SourceLine line)
{
        
        int f=0;
        int p=0;
        int nf=0;
        
        for(int n=0;n<lines.size();n++)
        {
                SourceLine & q = lines[n];
                
                bool found=false;
                bool partial=false;
                
                
                if(q.source_type==line.source_type && q.uri_type==line.uri_type
                && q.uri==line.uri && q.dist==line.dist)
                {
                        found=true;
                        partial=true;
                        
                        for(string c : q.components)
                        {
                                bool cfound=false;
                                
                                for(string cc : line.components)
                                {
                                        if(cc==c)cfound=true;
                                }
                                
                                if(!cfound)found=false;
                        }
                }
                
                if(found)
                {
                        f++;
                }
                else
                {
                        if(partial)
                        {
                                p++;
                        }
                        else
                        {
                                nf++;
                        }
                }
        }
        
        
        FindLineStatus ret;
        
        if(f>0)
        {
                ret=FindLineStatus::Found;
        }
        else
        {
                if(p>0)
                {
                        ret=FindLineStatus::Partial;
                }
                else
                {
                        ret=FindLineStatus::NotFound;
                }
        }
        
        return ret;
}

Sources net::lliurex::apt::operator+(Sources & A,Sources & B)
{
        Sources R;
        
        
        R.lines = A.lines;
        
        for(SourceLine line : B.lines)
        {
                R.Push(line);
        }
        
        return R;
}


void Sources::Print()
{

        
        for(int n=0;n<lines.size();n++)
        {
                SourceLine & q = lines[n];

                cout<<q.ToString()<<endl;

        }
}


void Sources::Write(string filename)
{

        ofstream file;
        string out;
        string err;
        int ret;
        
        file.open("/tmp/llx-apt-sources.list");

        for(int n=0;n<lines.size();n++)
        {
                SourceLine & q = lines[n];

                file<<q.ToString()<<endl;

        }

        file.close();
        
        Glib::spawn_command_line_sync("llx-apt-backend /tmp/llx-apt-sources.list "+filename,&out,&err,&ret);

                
        
        if(ret!=0)
        {
                cout<<"output:"<<endl;
                cout<<out<<endl;
        
                cout<<"err:"<<endl;
                cout<<err<<endl;
                throw std::runtime_error("Failed to write "+filename);
        }
}