定名管道Linux

 管道是

毫不相干的进程进程间通讯::定名管道
管道

起首本身要用用户层缓冲区，还得把用户层缓冲区拷贝到管道里，（从键盘里输入数据到用户层缓冲区内里），然后用户层缓冲区通过体系调用（write）写到管道里，然后再通过read体系调用，被对方（读端）读取，就要从管道拷贝到读端，然后再表现到表现器上。
mkfifo定名管道

1号手册是指令，。2号体系调用接口

创建一个管道，p开头就是定名管道，并不会直接革新到磁盘中，现实是个符号

这样会阻塞

这样会表现出来（先输入左边的，再输入右边的就会表现），左右两边是两个进程

>>追加写入的方式，但空间不停是0

以是这就是文件里大小不停是0的原因         

你怎么知道打开的是同一个文件

正好符合前提

以是要创建两个可执行程序，各自跑各自的，创建一个common是为了方便利用头文件        
client是客户   server是服务者

makefile中一下运行两个程序

mkfifo，用程序的方式创建管道，第一个参数是要创建的这个管道在那个路径下叫什么名字，也就是要保持唯一性的那些点，第二个是创建一个管道
这里是3号手册是函数。

返回 -1创建失败 

创建一个共享文件

./myfifo

server.cc和client.cc想看到同一个文件，包含上头文件就可以了

这里先用server控制管道文件

创建管道失败了设置为1 ,如果失败了就exit(1)

谁控制的先运行运行谁就好了

make一下生成两个可执行程序,因为是server控制的，以是要先运行server

运行后就会多一个myfifo定名管道

定名管道的删除

想删除这个myfifo用unlink(成功返回0 ，失败返回-1） 
下令行删除

代码也可以删(成功返回0 ，失败返回-1)，头文件是unistd.h


创建完文件，5秒后就删除了

思路

用到了open

打开管道文件，第二个参数是只进行读取

enum中

fd<0打开失败了

服务端读取数据

客户端，只要用就行
 第二个参数就是打开文件为了写入的

用户输入完成以后，就要发送输入的消息到另一端

打开次序肯定

然后打开的次序就肯定了，先打开server，然后再打开另一个cc
先打开服务端，会阻塞在这里，然后再打开客户端，进行输入

右边输入啥，左边就会有啥

无法输入空格标题（getline）

但有一个标题就是cin没法输入空格，，要用到getline

会发现一个标题，客户端退出了，服务端还没退出

客户端退出，会read到0，以是服务端（读端）也要退出

 改正

sever端

等待写入方式打开后，本身才会打开文件，向后执行，open阻塞了！


优化一下

写成进程池的样子

日志

创建一个新文件

用到了可变参数(形参实例化是从右到左)

可变参数必须右至少一个详细的参数
举个例子：步骤：s指向可变部分
这里的sum第一个参数是几个数求和的意思，传差异的范例不可以的，因为上面va_arg里已经写死了

开始写日志，level日志等级

先定义时间，time，时间戳

ctime

头文件

打印详细年代日 
年是从1900年开始的

 年代日时分秒

vsnprint

vsnprint，跟不带v的区别就是，去除了...换成了可变参数部分

把日志等级转换成字符串风格,全部有大概的地方都需要返回

改进
va_start(s,format)，用format修饰s的指向，上面的sum是（s,n),类似
这里要用c_str，因为返回的是string

用完以后再用end

这里是往表现器打印的,这里要*3，以为%s和%s中心有几个空格，空间不敷

把这里修改一下,打开失败的话

这样就形成日志了

打印末了一行就是正常打开

这里也改一下

测试，先./server，然后会阻塞，然后./client，就会打印出,logmessage里的信息

为啥./client之前不打印

因为等待写入方式打开后，本身才会打开文件，向后执行，open阻塞了！

往文件里打印（上面是往屏幕打印）

先把这些内容全放在Log,日志类

分类

1：向屏幕打印
2：向一个文件打印
3：分类打印

打印格式printMethod

这里构造默认往屏幕去印

析构

打印方式也改一下

打印单个
以0666的权限打开这个文件

打印多个文件（添加一下level）

实现一下

优化一下

以后再打印日志就不消这样打了

这样就可以了，要记住先创建一个Log对象

这样以后就写入一个文件了，写入log.txt

这样就把日志分类了

结果

但是日志文件这么多太杂乱了
这样操纵后就同一进入一个文件了

makefile也修改一下，先把path定义的log目录创建一下

日志放入一个文件测试结果：

日志分类测试结果：

log.hpp里头文件

优化一下调用

然后修改一下server.cc

 

client.cc

1. #include "common.hpp"
2. #include "log.hpp"
4. int main()
5. {
6.     int fd = open(FIFO_FILE,O_WRONLY);
7.     if(fd < 0)
8.     {
9.         perror("open");
10.         exit(FIFO_OPEN_ERR);
11.     }
12.     string line;
13.     while(true)
14.     {
15.         cout<< "Please Enter@ ";
16.         // cin>> line;
17.         getline(cin, line);
19.         write(fd, line.c_str(),line.size());
20.     }
22.     close(fd);
23.     return 0;
24. }

复制代码

common.hpp

1. #pragma noce
2. #include<iostream>
3. #include<vector>
4. #include<string>
5. #include<unistd.h>
6. #include <sys/types.h>
7. #include <sys/wait.h>
8. #include <sys/stat.h>
9. #include<fcntl.h>
10. #include<stdio.h>
11. using namespace std;
13. #define FIFO_FILE "./myfifo"
14. #define MODE 0664 //用于设置文件的权限，0664代表着8进制写法，4是其他用户可读不可写
16. enum
17. {
18.     FIFO_CREATE_ERR = 1,
19.     FIFO_DELETE_ERR,
20.     FIFO_OPEN_ERR
21. };
23. class Init
24. {
25. public:
26.     Init()
27.     {
28.         //创建管道
29.         int n = mkfifo(FIFO_FILE,MODE);
30.         if(n == -1)
31.         {
32.             perror("mkfofi");
33.             exit(FIFO_CREATE_ERR);
34.         }
35.     }
36.     ~Init()
37.     {
38.          //删除命名管道
39.         int m = unlink(FIFO_FILE);
40.         if(m == -1)
41.         {
42.             perror("unlink");
43.             exit(FIFO_DELETE_ERR);
44.         }      
45.     }
46. };

复制代码

log.hpp

1. #pragma noce
2. #include <stdarg.h>
3. // #include "common.hpp"
4. #include <iostream>
5. #include <stdio.h>
6. #include<string.h>//strerror(errno)头文件
7. #include<stdlib.h>
8. using namespace std;
10. #define Info        0
11. #define Debug       1
12. #define Warning     2
13. #define Error       3
14. #define Fatal       4 // 致命的
16. //打印方式
17. #define Screen      1 //屏幕
18. #define Onefile     2 //一个文件
19. #define Classfile   3 //多个文件
21. #define LogFile    "log.txt"
23. class Log
24. {
25. public:
26.     Log()
27.     {
28.         printMehod = Screen;
29.         path = "./log/";
30.     }
31.     void Enable(int method)
32.     {
33.         printMehod = method;
34.     }
35.     string levelToString(int level)
36.     {
37.         switch (level)
38.         {
39.         case Info:
40.             return "Info";
41.         case Debug:
42.             return "Debug";
43.         case Warning:
44.             return "Warning";
45.         case Error:
46.             return "Error";
47.         case Fatal:
48.             return "Fatal";
49.         default:
50.             return "";
51.         }
52.         return "";
53.     }
54.     // void logmessage(int level, const char *format, ...)
55.     // {
56.     //     time_t t = time(nullptr);
57.     //     struct tm *ctime = localtime(&t);
58.     //     char leftbuffer[1024];
59.     //     snprintf(leftbuffer, sizeof(leftbuffer), "[%s][%d-%d-%d  %d:%d:%d]", levelToString(level).c_str(),
60.     //             ctime->tm_year + 1900, ctime->tm_mon + 1, ctime->tm_mday, ctime->tm_hour, ctime->tm_min, ctime->tm_sec);
62.     //     va_list s;
63.     //     va_start(s, format);
64.     //     char rightbuffer[1024];
65.     //     vsnprintf(rightbuffer, sizeof(rightbuffer), format, s);
66.     //     va_end(s);
68.     //     // 格式：默认部分+自定义部分
69.     //     char logtxt[1024 * 3];
70.     //     snprintf(logtxt, sizeof(logtxt), "%s  %s\n", leftbuffer, rightbuffer);
71.     //     //cout << logtxt << endl; // 暂时打印
72.     //     printLog(level, logtxt);
73.     // }
74.     void operator()(int level, const char* format, ...)
75.     {
76.         time_t t = time(nullptr);
77.         struct tm *ctime = localtime(&t);
78.         char leftbuffer[1024];
79.         snprintf(leftbuffer, sizeof(leftbuffer), "[%s][%d-%d-%d  %d:%d:%d]", levelToString(level).c_str(),
80.                 ctime->tm_year + 1900, ctime->tm_mon + 1, ctime->tm_mday, ctime->tm_hour, ctime->tm_min, ctime->tm_sec);
82.         va_list s;
83.         va_start(s, format);
84.         char rightbuffer[1024];
85.         vsnprintf(rightbuffer, sizeof(rightbuffer), format, s);
86.         va_end(s);
88.         // 格式：默认部分+自定义部分
89.         char logtxt[1024 * 3];
90.         snprintf(logtxt, sizeof(logtxt), "%s  %s\n", leftbuffer, rightbuffer);
91.         //cout << logtxt << endl; // 暂时打印
92.         printLog(level, logtxt);
93.     }
95.     void printLog(int level, const string &logtxt)
96.     {
97.         switch(printMehod)
98.         {
99.             case Screen:
100.                 cout<< logtxt <<endl;
101.             break;
102.             case Onefile:
103.                 printOneFile(LogFile, logtxt);//"log.txt"
104.             break;
105.             case Classfile:
106.                 printClassFile(level, logtxt);
107.             break;
108.             default:
109.             break;
110.         }
112.     }
113.     void printOneFile(const string &logname, const string &logtxt)
114.     {
115.         //          "./log/" "log.txt"
116.         string _logname =path + logname;
117.         int fd = open(_logname.c_str(), O_WRONLY|O_CREAT|O_APPEND, 0666);
118.         if(fd < 0) return;
119.         write(fd, logtxt.c_str(), logtxt.size());
120.         close(fd);
121.     }
122.     void printClassFile(int level, const string &logtxt)
123.     {
124.         string filename = LogFile;//"log.txt"
125.         filename += ".";//"log.txt."
126.         filename += levelToString(level); //log.txt.Debug/Waring/Fatal
127.         printOneFile(filename, logtxt);
128.     }
129.     ~Log()
130.     {}
131. private:
132.     int printMehod;
133.     string path;
134. };

复制代码

makefile

1. .PHONY:all
2. all:client server
3. server:server.cc
4.         g++ -o $@ $^ -g -std=c++11
5.         mkdir log
6. client:client.cc
7.         g++ -o $@ $^ -g -std=c++11
8. .PHONY:clean
9. clean:
10.         rm -f server client

复制代码

server.cc

1. #include "common.hpp"
2. #include "log.hpp"
5. int main()
6. {
7.     //logmessage(Info, "hello");
8.     //创建管道
9.     Init init;
10.     Log log;
11.     //log.Enable(Onefile);
12.     log.Enable(Classfile);
14.     // //创建管道
15.     // int n = mkfifo(FIFO_FILE,MODE);
16.     // if(n == -1)
17.     // {
18.     //     perror("mkfofi");
19.     //     exit(FIFO_CREATE_ERR);
20.     // }
21.     // sleep(5);
22.     //打开管道
23.     int fd = open(FIFO_FILE,O_RDONLY);
24.     if(fd < 0)
25.     {
26.         //log.logmessage(Fatal, "error string:%s,error code:%d",strerror(errno), errno);
27.         //优化后
28.         log(Fatal, "error string:%s,error code:%d",strerror(errno), errno);
29.         exit(FIFO_OPEN_ERR);
30.     }
31.     // log.logmessage(Info, "server open file done,error string:%s,error code:%d",strerror(errno), errno);
32.     // log.logmessage(Warning, "server open file done,error string:%s,error code:%d",strerror(errno), errno);
33.     //优化后
34.     log(Info, "server open file done,error string:%s,error code:%d",strerror(errno), errno);
35.     log(Warning, "server open file done,error string:%s,error code:%d",strerror(errno), errno);
36.     //......
37.     //开始通信
38.     while(true)
39.     {
40.         char buffer[1024] = {0};
41.         int x = read(fd, buffer, sizeof(buffer));
42.         if(x > 0)
43.         {
44.             buffer[x] = 0;
45.             cout<< "client say# " << buffer <<endl;
46.         }
47.         else if(x == 0)
48.         {
49.             //log.logmessage(Debug, "sclient quit too!,error string:%s,error code:%d",strerror(errno), errno);
50.             //优化后
51.             log(Debug, "sclient quit too!,error string:%s,error code:%d",strerror(errno), errno);
53.             //cout<< "client quit too!\n" <<endl;
54.             break;
55.         }
56.         else break;
57.     }
58.     close(fd);
60.     // //删除命名管道
61.     // int m = unlink(FIFO_FILE);
62.     // if(n == -1)
63.     // {
64.     //     perror("unlink");
65.     //     exit(FIFO_DELETE_ERR);
66.     // }
69.     return 0;
70. }

复制代码

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。