tars源码分析之8

最新推荐文章于 2023-02-20 00:28:52 发布
最新推荐文章于 2023-02-20 00:28:52 发布
阅读量401 收藏 1
点赞数 3
分类专栏： S1: C/C++ s2: tarsC++ 文章标签： 前端 java javascript
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/stpeace/article/details/125591249
版权

在做软件开发时，配置可少不了，我不建议你再写了，直接看如下的代码吧：

#include <errno.h>
#include <fstream>
#include "util/tc_config.h"
#include "util/tc_common.h"

namespace tars
{

TC_ConfigDomain::TC_ConfigDomain(const string &sLine)
{
    _name = TC_Common::trim(sLine);
}

TC_ConfigDomain::~TC_ConfigDomain()
{
    destroy();
}

TC_ConfigDomain::TC_ConfigDomain(const TC_ConfigDomain &tcd)
{
    (*this) = tcd;
}

TC_ConfigDomain& TC_ConfigDomain::operator=(const TC_ConfigDomain &tcd)
{
    if(this != &tcd)
    {
        destroy();

        _name  = tcd._name;
        _param = tcd._param;
        _key   = tcd._key;
        _domain= tcd._domain;
        _line  = tcd._line;

        const map<string, TC_ConfigDomain*> & m = tcd.getDomainMap();
        map<string, TC_ConfigDomain*>::const_iterator it = m.begin();
        while(it != m.end())
        {
            _subdomain[it->first] = it->second->clone();
            ++it;
        }
    }
    return *this;
}

TC_ConfigDomain::DomainPath TC_ConfigDomain::parseDomainName(const string& path, bool bWithParam)
{
    TC_ConfigDomain::DomainPath dp;

    if(bWithParam)
    {
        string::size_type pos1 = path.find_first_of(TC_CONFIG_PARAM_BEGIN);
        if(pos1 == string::npos)
        {
            throw TC_Config_Exception("[TC_Config::parseDomainName] : param path '" + path + "' is invalid!" );
        }

        if(path[0] != TC_CONFIG_DOMAIN_SEP)
        {
            throw TC_Config_Exception("[TC_Config::parseDomainName] : param path '" + path + "' must start with '/'!" );
        }

        string::size_type pos2 = path.find_first_of(TC_CONFIG_PARAM_END);
        if(pos2 == string::npos)
        {
            throw TC_Config_Exception("[TC_Config::parseDomainName] : param path '" + path + "' is invalid!" );
        }

        dp._domains = TC_Common::sepstr<string>(path.substr(1, pos1-1), TC_Common::tostr(TC_CONFIG_DOMAIN_SEP));
        dp._param = path.substr(pos1+1, pos2 - pos1 - 1);
    }
    else
    {
//        if(path.length() <= 1 || path[0] != TC_CONFIG_DOMAIN_SEP)
        if(path[0] != TC_CONFIG_DOMAIN_SEP)
        {
            throw TC_Config_Exception("[TC_Config::parseDomainName] : param path '" + path + "' must start with '/'!" );
        }

        dp._domains = TC_Common::sepstr<string>(path.substr(1), TC_Common::tostr(TC_CONFIG_DOMAIN_SEP));
    }

    return dp;
}

TC_ConfigDomain* TC_ConfigDomain::addSubDomain(const string& name)
{
    if(_subdomain.find(name) == _subdomain.end())
    {
        _domain.push_back(name);

        _subdomain[name] = new TC_ConfigDomain(name);
    }
    return _subdomain[name];
}

string TC_ConfigDomain::getParamValue(const string &name) const
{
    map<string, string>::const_iterator it = _param.find(name);
    if( it == _param.end())
    {
        throw TC_ConfigNoParam_Exception("[TC_ConfigDomain::getParamValue] param '" + name + "' not exits!");
    }

    return it->second;
}

TC_ConfigDomain *TC_ConfigDomain::getSubTcConfigDomain(vector<string>::const_iterator itBegin, vector<string>::const_iterator itEnd)
{
    if(itBegin == itEnd)
    {
        return this;
    }

    map<string, TC_ConfigDomain*>::const_iterator it = _subdomain.find(*itBegin);

    //根据匹配规则找不到匹配的子域
    if(it == _subdomain.end())
    {
        return NULL;
    }

    //继续在子域下搜索
    return it->second->getSubTcConfigDomain(itBegin + 1, itEnd);
}

const TC_ConfigDomain *TC_ConfigDomain::getSubTcConfigDomain(vector<string>::const_iterator itBegin, vector<string>::const_iterator itEnd) const
{
    if(itBegin == itEnd)
    {
        return this;
    }

    map<string, TC_ConfigDomain*>::const_iterator it = _subdomain.find(*itBegin);

    //根据匹配规则找不到匹配的子域
    if(it == _subdomain.end())
    {
        return NULL;
    }

    //继续在子域下搜索
    return it->second->getSubTcConfigDomain(itBegin + 1, itEnd);
}

void TC_ConfigDomain::insertParamValue(const map<string, string> &m)
{
    _param.insert(m.begin(),  m.end());

    map<string, string>::const_iterator it = m.begin();
    while(it != m.end())
    {
        size_t i = 0;
        for(; i < _key.size(); i++)
        {
            if(_key[i] == it->first)
            {
                break;
            }
        }

        //没有该key, 则添加到最后
        if(i == _key.size())
        {
            _key.push_back(it->first);
        }

        ++it;
    }
}

void TC_ConfigDomain::setParamValue(const string &name, const string &value)
{
    _param[name] = value;

    //如果key已经存在,则删除
    for(vector<string>::iterator it = _key.begin(); it != _key.end(); ++it)
    {
        if(*it == name)
        {
            _key.erase(it);
            break;
        }
    }

    _key.push_back(name);
}

void TC_ConfigDomain::setParamValue(const string &line)
{
    if(line.empty())
    {
        return;
    }

    _line.push_back(line);

    string::size_type pos = 0;
    for(; pos <= line.length() - 1; pos++)
    {
        if (line[pos] == '=')
        {
            if(pos > 0 && line[pos-1] == '\\')
            {
                continue;
            }

            string name  = parse(TC_Common::trim(line.substr(0, pos), " \r\n\t"));

            string value;
            if(pos < line.length() - 1)
            {
                value = parse(TC_Common::trim(line.substr(pos + 1), " \r\n\t"));
            }

            setParamValue(name, value);
            return;
        }
    }

    setParamValue(line, "");
}

string TC_ConfigDomain::parse(const string& s)
{
    if(s.empty())
    {
        return "";
    }

    string param;
    string::size_type pos = 0;
    for(; pos <= s.length() - 1; pos++)
    {
        char c;
        if(s[pos] == '\\' && pos < s.length() - 1)
        {
            switch (s[pos+1])
            {
            case '\\':
                c = '\\';
                pos++;
                break;
            case 'r':
                c = '\r';
                pos++;
                break;
            case 'n':
                c = '\n';
                pos++;
                break;
            case 't':
                c = '\t';
                pos++;
                break;
            case '=':
                c = '=';
                pos++;
                break;
            default:
                throw TC_Config_Exception("[TC_ConfigDomain::parse] '" + s + "' is invalid, '" + TC_Common::tostr(s[pos]) + TC_Common::tostr(s[pos+1]) + "' couldn't be parse!" );
            }

            param += c;
        }
        else if (s[pos] == '\\')
        {
            throw TC_Config_Exception("[TC_ConfigDomain::parse] '" + s + "' is invalid, '" + TC_Common::tostr(s[pos]) + "' couldn't be parse!" );
        }
        else
        {
            param += s[pos];
        }
    }

    return param;
}

string TC_ConfigDomain::reverse_parse(const string &s)
{
    if(s.empty())
    {
        return "";
    }

    string param;
    string::size_type pos = 0;
    for(; pos <= s.length() - 1; pos++)
    {
        string c;
        switch (s[pos])
        {
        case '\\':
            param += "\\\\";
            break;
        case '\r':
            param += "\\r";
            break;
        case '\n':
            param += "\\n";
            break;
        case '\t':
            param += "\\t";
            break;
            break;
        case '=':
            param += "\\=";
            break;
        case '<':
        case '>':
            throw TC_Config_Exception("[TC_ConfigDomain::reverse_parse] '" + s + "' is invalid, couldn't be parse!" );
        default:
            param += s[pos];
        }
    }

    return param;
}

string TC_ConfigDomain::getName() const
{
    return _name;
}

void TC_ConfigDomain::setName(const string& name)
{
    _name = name;
}

vector<string> TC_ConfigDomain::getKey() const
{
    return _key;
}

vector<string> TC_ConfigDomain::getLine() const
{
    return _line;
}

vector<string> TC_ConfigDomain::getSubDomain() const
{
    return _domain;
}

void TC_ConfigDomain::destroy()
{
    _param.clear();
    _key.clear();
    _line.clear();
    _domain.clear();

    map<string, TC_ConfigDomain*>::iterator it = _subdomain.begin();
    while(it != _subdomain.end())
    {
        delete it->second;
        ++it;
    }

    _subdomain.clear();
}

string TC_ConfigDomain::tostr(int i) const
{
    string sTab;
    for(int k = 0; k < i; ++k)
    {
        sTab += "\t";
    }

    ostringstream buf;

    buf << sTab << "<" << reverse_parse(_name) << ">" << endl;;

    for(size_t n = 0; n < _key.size(); n++)
    {
        map<string, string>::const_iterator it = _param.find(_key[n]);

        assert(it != _param.end());

        //值为空, 则不打印出=
        if(it->second.empty())
        {
            buf << "\t" << sTab << reverse_parse(_key[n]) << endl;
        }
        else
        {
            buf << "\t" << sTab << reverse_parse(_key[n]) << "=" << reverse_parse(it->second) << endl;
        }
    }

    ++i;

    for(size_t n = 0; n < _domain.size(); n++)
    {
        map<string, TC_ConfigDomain*>::const_iterator itm = _subdomain.find(_domain[n]);

        assert(itm != _subdomain.end());

        buf << itm->second->tostr(i);
    }


    buf << sTab << "</" << reverse_parse(_name) << ">" << endl;

    return buf.str();
}

/********************************************************************/
/*        TC_Config implement                                            */
/********************************************************************/

TC_Config::TC_Config() : _root("")
{
}

TC_Config::TC_Config(const TC_Config &tc)
: _root(tc._root)
{

}

TC_Config& TC_Config::operator=(const TC_Config &tc)
{
    if(this != &tc)
    {
        _root = tc._root;
    }

    return *this;
}

void TC_Config::parse(istream &is)
{
    _root.destroy();

    stack<TC_ConfigDomain*> stkTcCnfDomain;
    stkTcCnfDomain.push(&_root);

    string line;
    while(getline(is, line))
    {
        line = TC_Common::trim(line, " \r\n\t");

        if(line.length() == 0)
        {
            continue;
        }

        if(line[0] == '#')
        {
            continue;
        }
        else if(line[0] == '<')
        {
            string::size_type posl = line.find_first_of('>');

            if(posl == string::npos)
            {
                throw TC_Config_Exception("[TC_Config::parse]:parse error! line : " + line);
            }

            if(line[1] == '/')
            {
                string sName(line.substr(2, (posl - 2)));

                if(stkTcCnfDomain.size() <= 0)
                {
                    throw TC_Config_Exception("[TC_Config::parse]:parse error! <" + sName + "> hasn't matched domain.");
                }

                if(stkTcCnfDomain.top()->getName() != sName)
                {
                    throw TC_Config_Exception("[TC_Config::parse]:parse error! <" + stkTcCnfDomain.top()->getName() + "> hasn't match <" + sName +">.");
                }

                //弹出
                stkTcCnfDomain.pop();
            }
            else
            {
                string name(line.substr(1, posl - 1));

                stkTcCnfDomain.push(stkTcCnfDomain.top()->addSubDomain(name));
            }
        }
        else
        {
            stkTcCnfDomain.top()->setParamValue(line);
        }
    }

    if(stkTcCnfDomain.size() != 1)
    {
        throw TC_Config_Exception("[TC_Config::parse]:parse error : hasn't match");
    }
}

void TC_Config::parseFile(const string &sFileName)
{
    if(sFileName.length() == 0)
    {
        throw TC_Config_Exception("[TC_Config::parseFile]:file name is empty");
    }

    ifstream ff;
    ff.open(sFileName.c_str());
    if (!ff)
    {
        throw TC_Config_Exception("[TC_Config::parseFile]:fopen fail: " + sFileName, errno);
    }

    parse(ff);
}

void TC_Config::parseString(const string& buffer)
{
    istringstream iss;
    iss.str(buffer);

    parse(iss);
}

string TC_Config::operator[](const string &path)
{
    TC_ConfigDomain::DomainPath dp = TC_ConfigDomain::parseDomainName(path, true);

    TC_ConfigDomain *pTcConfigDomain = searchTcConfigDomain(dp._domains);

    if(pTcConfigDomain == NULL)
    {
        throw TC_ConfigNoParam_Exception("[TC_Config::operator[]] path '" + path + "' not exits!");
    }

    return pTcConfigDomain->getParamValue(dp._param);
}

string TC_Config::get(const string &sName, const string &sDefault) const
{
    try
    {
        TC_ConfigDomain::DomainPath dp = TC_ConfigDomain::parseDomainName(sName, true);

        const TC_ConfigDomain *pTcConfigDomain = searchTcConfigDomain(dp._domains);

        if(pTcConfigDomain == NULL)
        {
            throw TC_ConfigNoParam_Exception("[TC_Config::get] path '" + sName + "' not exits!");
        }

        return pTcConfigDomain->getParamValue(dp._param);
    }
    catch ( TC_ConfigNoParam_Exception &ex )
    {
        return sDefault;
    }
}

bool TC_Config::getDomainMap(const string &path, map<string, string> &m) const
{
    TC_ConfigDomain::DomainPath dp = TC_ConfigDomain::parseDomainName(path, false);

    const TC_ConfigDomain *pTcConfigDomain = searchTcConfigDomain(dp._domains);

    if(pTcConfigDomain == NULL)
    {
        return false;
    }

    m = pTcConfigDomain->getParamMap();

    return true;
}

map<string, string> TC_Config::getDomainMap(const string &path) const
{
    map<string, string> m;

    TC_ConfigDomain::DomainPath dp = TC_ConfigDomain::parseDomainName(path, false);

    const TC_ConfigDomain *pTcConfigDomain = searchTcConfigDomain(dp._domains);

    if(pTcConfigDomain != NULL)
    {
        m = pTcConfigDomain->getParamMap();
    }

    return m;
}

vector<string> TC_Config::getDomainKey(const string &path) const
{
    vector<string> v;

    TC_ConfigDomain::DomainPath dp = TC_ConfigDomain::parseDomainName(path, false);

    const TC_ConfigDomain *pTcConfigDomain = searchTcConfigDomain(dp._domains);

    if(pTcConfigDomain != NULL)
    {
        v = pTcConfigDomain->getKey();
    }

    return v;
}

vector<string> TC_Config::getDomainLine(const string &path) const
{
    vector<string> v;

    TC_ConfigDomain::DomainPath dp = TC_ConfigDomain::parseDomainName(path, false);

    const TC_ConfigDomain *pTcConfigDomain = searchTcConfigDomain(dp._domains);

    if(pTcConfigDomain != NULL)
    {
        v = pTcConfigDomain->getLine();
    }

    return v;
}

bool TC_Config::getDomainVector(const string &path, vector<string> &vtDomains) const
{
    TC_ConfigDomain::DomainPath dp = TC_ConfigDomain::parseDomainName(path, false);

    //根域, 特殊处理
    if(dp._domains.empty())
    {
        vtDomains = _root.getSubDomain();
        return !vtDomains.empty();
    }

    const TC_ConfigDomain *pTcConfigDomain = searchTcConfigDomain(dp._domains);

    if(pTcConfigDomain == NULL)
    {
        return false;
    }

    vtDomains = pTcConfigDomain->getSubDomain();

    return true;
}

vector<string> TC_Config::getDomainVector(const string &path) const
{
    TC_ConfigDomain::DomainPath dp = TC_ConfigDomain::parseDomainName(path, false);

    //根域, 特殊处理
    if(dp._domains.empty())
    {
        return _root.getSubDomain();
    }

    const TC_ConfigDomain *pTcConfigDomain = searchTcConfigDomain(dp._domains);

    if(pTcConfigDomain == NULL)
    {
        return vector<string>();
    }

    return pTcConfigDomain->getSubDomain();
}


TC_ConfigDomain *TC_Config::newTcConfigDomain(const string &sName)
{
    return new TC_ConfigDomain(sName);
}

TC_ConfigDomain *TC_Config::searchTcConfigDomain(const vector<string>& domains)
{
    return _root.getSubTcConfigDomain(domains.begin(), domains.end());
}

const TC_ConfigDomain *TC_Config::searchTcConfigDomain(const vector<string>& domains) const
{
    return _root.getSubTcConfigDomain(domains.begin(), domains.end());
}

int TC_Config::insertDomain(const string &sCurDomain, const string &sAddDomain, bool bCreate)
{
    TC_ConfigDomain::DomainPath dp = TC_ConfigDomain::parseDomainName(sCurDomain, false);

    TC_ConfigDomain *pTcConfigDomain = searchTcConfigDomain(dp._domains);

    if(pTcConfigDomain == NULL)
    {
        if(bCreate)
        {
            pTcConfigDomain = &_root;

            for(size_t i = 0; i < dp._domains.size(); i++)
            {
                pTcConfigDomain = pTcConfigDomain->addSubDomain(dp._domains[i]);
            }
        }
        else
        {
            return -1;
        }
    }

    pTcConfigDomain->addSubDomain(sAddDomain);

    return 0;
}

int TC_Config::insertDomainParam(const string &sCurDomain, const map<string, string> &m, bool bCreate)
{
    TC_ConfigDomain::DomainPath dp = TC_ConfigDomain::parseDomainName(sCurDomain, false);

    TC_ConfigDomain *pTcConfigDomain = searchTcConfigDomain(dp._domains);

    if(pTcConfigDomain == NULL)
    {
        if(bCreate)
        {
            pTcConfigDomain = &_root;

            for(size_t i = 0; i < dp._domains.size(); i++)
            {
                pTcConfigDomain = pTcConfigDomain->addSubDomain(dp._domains[i]);
            }
        }
        else
        {
            return -1;
        }
    }

    pTcConfigDomain->insertParamValue(m);

    return 0;
}

string TC_Config::tostr() const
{
    string buffer;

    map<string, TC_ConfigDomain*> msd = _root.getDomainMap();
    map<string, TC_ConfigDomain*>::const_iterator it = msd.begin();
    while (it != msd.end())
    {
        buffer += it->second->tostr(0);
        ++it;
    }

    return buffer;
}

void TC_Config::joinConfig(const TC_Config &cf, bool bUpdate)
{
    string buffer;
    if(bUpdate)
    {
        buffer = tostr() + cf.tostr();
    }
    else
    {
        buffer = cf.tostr() + tostr();
    }
    parseString(buffer);
}

}

涛歌依旧
关注
  • 3
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
tar-1.28.tar.gz源码包
10-16
tar工具源码包，可以解决buildroot构建时缺少tar包的报错
tar 包的解析
最新发布
swl_lidy的博客
03-10 608
tar 包解析文件样例
linux tar源码,linux源代码包（.tar.gz）制作
weixin_36410904的博客
05-12 375
本文以“hello world”程序为例，简单说明linux下源代码包(.tar.gz)的制作。首先，确保你的系统装有以下GNU软件：AutomakeAutoconfm4perllibtool1.新建一目录，将你的源代码放在此目录下，以下的操作均在此目录里进行。shell> mkdir hello2.执行autoscan命令来扫描源代码。shell>autoscan执行该命令后会生成c...
tar-1.28.tar.gz_tar_tar 压缩源码_tar 原理_tar-1.28.tar
07-15
GNU 的tar源码。 了解压缩相关原理。 tar-1.28.tar.gz
Linux下 tar命令(工具)的移植，源码下载、详细移植步骤
wkd_007的博客
10-14 3129
tar命令是Linux系统下的解压缩命令，本文介绍其详细移植步骤。 在使用busybox移植文件系统时，busybox一般有自带的，但可能出现有些版本比较旧，无法解压缩tar.gzx Extractt List$如上，busybox自带的tar命令无法识别到z选项，而busybox是原厂编译好提供的，所以考虑自己移植tar命令。
tars
03-15
《深入理解Tars框架》 Tars是一种高性能、可扩展的分布式服务框架，源自腾讯内部的服务治理系统。在现代互联网业务中，面对日益复杂的系统架构和海量数据处理，Tars提供了一种有效的解决方案。本文将从Tars的核心...
K8STARS:TARS服务的本地Kubernetes解决方案
05-03
K8STARS K8STARS是在kubernetes中运行TARS服务的便捷解决方案。特征保持TARS的本机开发能力自动注册和删除TARS的名称服务支持将原始的TARS服务顺利迁移到K8S和其他容器平台非侵入式设计，与操作环境无耦合关系这个...
laravel-tars:Laravel的Tars驱动程序
04-11
Laravel Tars Driver中文版描述Tars driver for laravel.Laravel集成微服务治理框架Tars功能支持服务打包支持Laravel/Lumen原生开发支持TarsConfig支持TarsLog支持网关注册下线支持请求开始(laravel.tars.requesting...
tars 资料安装包
07-01
【Tars资料安装包】是针对Tars框架的一份综合资源集合，包含了多个关键组件的安装包，旨在帮助用户快速搭建和部署Tars服务。Tars是一个基于微服务架构的高性能、可扩展的服务框架，广泛应用于分布式系统开发。在这个...
Tars深度融合K8S的开源项目1.2.3版本代码包K8SFramework-master_v1.2.3.zip
03-20
K8SFramework-v1.2.3.zip压缩包包含的是这个项目的源码，让我们一起深入探讨其中的核心知识点。 首先，Tars在K8S中的深度融合体现在服务治理上。Tars服务框架提供了强大的服务注册、发现、调用以及监控能力，而在K8...
tar:用C语言实现的简单tar实现
05-04
一个简单的tar实现 版权所有（c）2015 Jason Lee @ calcccrypto在gmail.com 请参阅许可文件以获得许可。 这只是tar文件格式的简单实现。 它可以压缩文件并解压缩它们。 就是这样。 尽管还编写了其他一些实用程序函数，但是它们是GNU Tar提供的很小的子集。 一切都是基于Wikipedia和GNU Tar的观察结果编写的。 由于使用了大量的POSIX头文件，因此这仅适用于Linux（或类似Linux的环境，例如cygwin）。 所需的最低C标准是C99。 这样做的目的是要成为可以在其他程序中使用的tar库，这样程序就不必在程序外部调用或执行tarring（例如，使用system，exec或通过脚本）。 建立： make - creates libtar.a make exec - makes the commandline inte
JAVA 打包（jar\tar\zip）源码
09-03
JAVA 打包（jar\tar\zip）源码 一个完整的java project工程
tar包源码安装整理
weixin_34290096的博客
04-13 524
1.Tarball 封包：.tar.gz 和 .tar.bz2 格式居多；软件素材参考：http://sourceforge.net 2.确认源代码编译环境：需安装支持 C/C++程序语言的 编译器gcc-4.1.1-52.el5、gcc-c++-4.1.1-52.el5 make-3.81-1.1.i386 …3.安装过程图解：注意：使用./configure生成的make...
linux tar源码,linux之tar命令备份
weixin_32506743的博客
05-12 226
大家好我是都百顺我的QQ：136882447Linux学习交流群：225961139官方网站：www.wmphp.com下讲我来给大家讲解，使用教程下载地址：http://pan.baidu.com/share/link?shareid=369090&uk=1493502493Linuxtar打包命令tar-c产生.tar打包文件-C切换到指定目录-x解包.tar文件-v...
linux tar源码,linux Tar 命令参数详解
weixin_39604350的博客
05-12 214
tar命令1. 作用 tar命令是Unix/Linux系统中备份文件的可靠方法，几乎可以工作于任何环境中，它的使用权限是所有用户。2. 格式 tar [主选项+辅选项] 文件或目录 eg: tar zxvf libiconv-1.13.tar.gz ./libiconv tar cxvf libiconv-1.13.tar.gz ./*.php3. 主要参数使用该命令时，主选项是必须要有...
在Deepin Linux下安装tar源码安装包
waS_TransvolnoS的博客
05-16 5920
前言 首先要说的是tar.gz不是软件包格式，而是压缩档格式，你可以把任何格式的东西压缩成tar.gz文件，就像.7z , .zip和.rar一样。 你下载的tar.gz包装的软件很可能是源码，但也有的地方把二进制码打包成tar.gz的，而deb包里包装的是二进制码和少量配置文件。把源码转换到deb文件的过程需要编译软件并制作配置文件，比较麻烦。 对于常见的软件，已经有人打包好了，都可以从软件源...
TAR RPM YUM 源代码编译安装
xyjmh的博客
02-20 784
清理缓存 yum clean packages //清除缓存中的rpm包文件 yum clearn headers //清除缓存中 的rpm头文件 yum clean oldheaders //清除缓存中旧的rpm头文件 yum clearn 或 yum clearn all //清除缓存中rpm包文件和旧的rpm头文件。永久挂载需要修改配置文件。cd /etc/yum.repos.d/ //切换至/etc/yum.repos.d/
tar 源码包管理-源码包安装方法
qdzhanghao的博客
04-20 3664
一、源码安装 nginx 1. 编译环境如 gcc 和 gcc-c++编译器，make 2. 准备软件 ： nginx-1.18.0.tar.gz 部署 Nginx 安装 nginx 源码编译，需要的依赖包： [root@tiehao ~]# yum -y install gcc gcc-c++ make zlib-devel pcre pcre-devel openssl-devel 软件包说明： gcc c 语言编译器。 gcc-c++ c++ 语言编译器。 make 用于 confi
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值