गो पर टीसीपी / आईपी प्रॉक्सी

मैं नई भाषाओं को सीखने के लिए अपने पसंदीदा काम पर लौट आया। गो पर ब्लॉग के लिए इंजन लिखने के बाद, मैं अपनी उंगलियों को फिर से खींचना चाहता था, बीमार टीसीपी / आईपी प्रॉक्सी / डीबगर अब गो में लिखा गया है।

संक्षेप में, टीसीपी / आईपी प्रॉक्सी एक ऐसा कार्यक्रम है जो कनेक्शन स्वीकार कर सकता है और उन्हें निर्दिष्ट पते पर अग्रेषित कर सकता है। रास्ते के साथ, संचरित डेटा के लॉग बनाए रखे जाते हैं। यह बहुत सुविधाजनक है जब विभिन्न घर-निर्मित नेटवर्क प्रोटोकॉल को डीबग करना है।

कार्यक्षमता के संदर्भ में, गो संस्करण, एर्लांग संस्करण की तरह, तीन लॉग हैं: द्वि-दिशात्मक हेक्साडेसिमल डंप और बाइनरी लॉग दोनों दिशाओं में, "से" और "से" दूरस्थ होस्ट तक। पायथन संस्करण बाइनरी लॉग का नेतृत्व नहीं करता है।

बेशक, सब कुछ बहुआयामी है। और चूंकि गो प्रोग्रामिंग गो में इतना सरल (और सुरक्षित) है, इसलिए प्रत्येक कनेक्शन के लिए समानांतर गतिविधियों की संख्या एरलांग संस्करण की तुलना में अधिक है।

Erlang पर, प्रत्येक कनेक्शन के लिए निम्नलिखित चार प्रवाह ने काम किया:

• द्विदिश डंप लकड़हारा
• प्राप्त और भेजे गए डेटा के द्विआधारी लॉग के लिए दो धाराएं
• मुख्य धारा मल्टीप्लेक्सिंग स्थानीय और दूरस्थ सॉकेट से पढ़ी जाती है

गो पर संस्करण थोड़ा अलग है:

• द्विदिश डंप लकड़हारा
• प्राप्त और भेजे गए डेटा के द्विआधारी लॉग के लिए दो धाराएं
• एक स्थानीय और दूरस्थ सॉकेट से पढ़ने के लिए दो स्वतंत्र धाराएँ

कुल 5।

दोनों ही स्थितियों में, लॉग स्ट्रीम में संदेश भेजकर स्ट्रीम डेटा लॉग पढ़ें। बेशक, म्यूटेक्स या सशर्त चर जैसी कोई बेवकूफ चीजें नहीं हैं। मिलान चैनलों को गो चैनलों के माध्यम से शान्तिपूर्वक हल किया जाता है।

नीचे स्रोत कोड है। यह प्रचुर मात्रा में टिप्पणियों की उपस्थिति से रिपॉजिटरी में अलग है। गो से बहुत परिचित लोगों के लिए, कुछ बिंदु दिलचस्प हो सकते हैं।

package main import ( "flag" "fmt" "net" "os" "strings" "time" "encoding/hex" "runtime" ) var ( host *string = flag.String("host", "", "target host or address") port *string = flag.String("port", "0", "target port") listen_port *string = flag.String("listen_port", "0", "listen port") ) func die(format string, v ...interface{}) { os.Stderr.WriteString(fmt.Sprintf(format+"\n", v...)) os.Exit(1) } //       . func connection_logger(data chan []byte, conn_n int, local_info, remote_info string) { log_name := fmt.Sprintf("log-%s-%04d-%s-%s.log", format_time(time.Now()), conn_n, local_info, remote_info) logger_loop(data, log_name) } //     . func binary_logger(data chan []byte, conn_n int, peer string) { log_name := fmt.Sprintf("log-binary-%s-%04d-%s.log", format_time(time.Now()), conn_n, peer) logger_loop(data, log_name) } //     .  -   //  .   -      //  .     - . // func logger_loop(data chan []byte, log_name string) { f, err := os.Create(log_name) if err != nil { die("Unable to create file %s, %v\n", log_name, err) } defer f.Close() //      . for { b := <-data if len(b) == 0 { break } f.Write(b) f.Sync() //    flush'. } } func format_time(t time.Time) string { return t.Format("2006.01.02-15.04.05") } func printable_addr(a net.Addr) string { return strings.Replace(a.String(), ":", "-", -1) } // ,     . ,  //    . type Channel struct { from, to net.Conn logger, binary_logger chan []byte ack chan bool } // , ""         . //   . func pass_through(c *Channel) { from_peer := printable_addr(c.from.LocalAddr()) to_peer := printable_addr(c.to.LocalAddr()) b := make([]byte, 10240) offset := 0 packet_n := 0 for { n, err := c.from.Read(b) if err != nil { c.logger <- []byte(fmt.Sprintf("Disconnected from %s\n", from_peer)) break } if n > 0 { //  - ,      . c.logger <- []byte(fmt.Sprintf("Received (#%d, %08X) %d bytes from %s\n", packet_n, offset, n, from_peer)) //  ,      hex-. ,   ? c.logger <- []byte(hex.Dump(b[:n])) c.binary_logger <- b[:n] c.to.Write(b[:n]) c.logger <- []byte(fmt.Sprintf("Sent (#%d) to %s\n", packet_n, to_peer)) offset += n packet_n += 1 } } c.from.Close() c.to.Close() c.ack <- true //     ,   . } //    .      //  . func process_connection(local net.Conn, conn_n int, target string) { //    ,    . remote, err := net.Dial("tcp", target) if err != nil { fmt.Printf("Unable to connect to %s, %v\n", target, err) } local_info := printable_addr(remote.LocalAddr()) remote_info := printable_addr(remote.RemoteAddr()) //   . started := time.Now() //      . logger := make(chan []byte) from_logger := make(chan []byte) to_logger := make(chan []byte) //       . ack := make(chan bool) //  . go connection_logger(logger, conn_n, local_info, remote_info) go binary_logger(from_logger, conn_n, local_info) go binary_logger(to_logger, conn_n, remote_info) logger <- []byte(fmt.Sprintf("Connected to %s at %s\n", target, format_time(started))) //   . go pass_through(&Channel{remote, local, logger, to_logger, ack}) go pass_through(&Channel{local, remote, logger, from_logger, ack}) //     . <-ack <-ack //   . finished := time.Now() duration := finished.Sub(started) logger <- []byte(fmt.Sprintf("Finished at %s, duration %s\n", format_time(started), duration.String())) //    .       // ,         ,    //   . logger <- []byte{} from_logger <- []byte{} to_logger <- []byte{} } func main() { //  Go      . runtime.GOMAXPROCS(runtime.NumCPU()) //    (,   ?) flag.Parse() if flag.NFlag() != 3 { fmt.Printf("usage: gotcpspy -host target_host -port target_port -listen_post=local_port\n") flag.PrintDefaults() os.Exit(1) } target := net.JoinHostPort(*host, *port) fmt.Printf("Start listening on port %s and forwarding data to %s\n", *listen_port, target) ln, err := net.Listen("tcp", ":"+*listen_port) if err != nil { fmt.Printf("Unable to start listener, %v\n", err) os.Exit(1) } conn_n := 1 for { //   . if conn, err := ln.Accept(); err == nil { //    . go process_connection(conn, conn_n, target) conn_n += 1 } else { fmt.Printf("Accept failed, %v\n", err) } } } 

फिर से, प्रत्येक कनेक्शन को पांच थ्रेड्स द्वारा परोसा जाता है। और मैंने इसे मजे के लिए नहीं किया। यह सिर्फ मुझे लग रहा था कि तार्किक रूप से स्पष्ट रूप से स्वतंत्र उप-मुखौटे हैं जो समानांतर में चलाने के लिए तर्कसंगत होंगे। अगर मैंने C ++ / बूस्ट में सब कुछ लिखा है, तो मैं सबसे अधिक संभावना है कि प्रत्येक कनेक्शन के लिए एक धागे में सब कुछ पिघला दूंगा (या शायद पूरे कार्यक्रम को कुछ परिष्कृत मल्टीप्लेक्सिंग लाइब्रेरी के माध्यम से एकल-पिरोया जाएगा), और यह संभव है कि अंत में C ++ ++ में संभव हो। यह भी तेजी से काम करेगा, एक धागे के बावजूद। लेकिन यह वह नहीं है जो मैं कहना चाहता हूं। मल्टीथ्रेडेड प्रोग्रामिंग के लिए पुश (बजाय नए मानक के स्टेरॉयड पर भी, सी ++ की तरह पुश)। एक या दूसरे तरीके से, ऐसे कार्य होंगे जहां सुविधाजनक मल्टीथ्रेडिंग एक महत्वपूर्ण कारक बन जाएगा।

आप इसे इस तरह चला सकते हैं (कम से कम गो रिलीज़ 1 आवश्यक है):

 go run gotcpspy.go -host pop.yandex.ru -port 110 -local_port 8080 

यह प्रदर्शित करता है:

 Start listening on port 8080 and forwarding data to pop.yandex.ru:110 

फिर, यदि आप दूसरी विंडो में प्रवेश करते हैं:

 telnet localhost 8080 

और दर्ज करें, उदाहरण के लिए, " USER test " " ENTER " और " PASS none " " ENTER ", तो तीन लॉग बनाए जाएंगे (नाम में तारीख निश्चित रूप से अलग होगी)।

सामान्य लॉग log-2012.04.20-19.55.17-0001-192.168.1.41-49544-213.180.204.37-110.log :

  Connected to pop.yandex.ru:110 at 2012.04.20-19.55.17 Received (#0, 00000000) 38 bytes from 192.168.1.41-49544 00000000 2b 4f 4b 20 50 4f 50 20 59 61 21 20 76 31 2e 30 |+OK POP Ya! v1.0| 00000010 2e 30 6e 61 40 32 36 20 48 74 6a 4a 69 74 63 50 |.0na@26 HtjJitcP| 00000020 52 75 51 31 0d 0a |RuQ1..| Sent (#0) to [--1]-8080 Received (#0, 00000000) 11 bytes from [--1]-8080 00000000 55 53 45 52 20 74 65 73 74 0d 0a |USER test..| Sent (#0) to 192.168.1.41-49544 Received (#1, 00000026) 23 bytes from 192.168.1.41-49544 00000000 2b 4f 4b 20 70 61 73 73 77 6f 72 64 2c 20 70 6c |+OK password, pl| 00000010 65 61 73 65 2e 0d 0a |ease...| Sent (#1) to [--1]-8080 Received (#1, 0000000B) 11 bytes from [--1]-8080 00000000 50 41 53 53 20 6e 6f 6e 65 0d 0a |PASS none..| Sent (#1) to 192.168.1.41-49544 Received (#2, 0000003D) 72 bytes from 192.168.1.41-49544 00000000 2d 45 52 52 20 5b 41 55 54 48 5d 20 6c 6f 67 69 |-ERR [AUTH] logi| 00000010 6e 20 66 61 69 6c 75 72 65 20 6f 72 20 50 4f 50 |n failure or POP| 00000020 33 20 64 69 73 61 62 6c 65 64 2c 20 74 72 79 20 |3 disabled, try | 00000030 6c 61 74 65 72 2e 20 73 63 3d 48 74 6a 4a 69 74 |later. sc=HtjJit| 00000040 63 50 52 75 51 31 0d 0a |cPRuQ1..| Sent (#2) to [--1]-8080 Disconnected from 192.168.1.41-49544 Disconnected from [--1]-8080 Finished at 2012.04.20-19.55.17, duration 5.253979s 

आउटगोइंग बाइनरी लॉग log-binary-2012.04.20-19.55.17-0001-192.168.1.41-49544.log :

  USER test PASS none 

बाइनरी इनपुट log-binary-2012.04.20-19.55.17-0001-213.180.204.37-110.log :

  +OK POP Ya! v1.0.0na@26 HtjJitcPRuQ1 +OK password, please. -ERR [AUTH] login failure or POP3 disabled, try later. sc=HtjJitcPRuQ1 

अब प्रदर्शन को मापें। हम सीधे फ़ाइल को पंप करते हैं, और फिर इस प्रोग्राम के माध्यम से।

सीधे डाउनलोड करें (आकार में लगभग 72MB फ़ाइल):

  time wget http://www.erlang.org/download/otp_src_R15B01.tar.gz ... Saving to: `otp_src_R15B01.tar.gz' ... real 1m2.819s 

अब कार्यक्रम के माध्यम से डाउनलोड करें, इसे पहले से चलाना:

  go run gotcpspy.go -host=www.erlang.org -port=80 -listen_port=8080 

डाउनलोड कर रहा है:

  time wget http://localhost:8080/download/otp_src_R15B01.tar.gz ... Saving to: `otp_src_R15B01.tar.gz.1' ... real 0m56.209s 

बस मामले में, आप परिणामों की तुलना कर सकते हैं:

  diff otp_src_R15B01.tar.gz otp_src_R15B01.tar.gz.1

मेरी फाइलें समान हैं, इसलिए सब कुछ सही ढंग से काम करता है।

अब समय है। मैंने कई बार प्रयोग (मैक एयर पर) दोहराया, और, आश्चर्यजनक रूप से, कार्यक्रम के माध्यम से डाउनलोड करना हमेशा इतना धीमा नहीं था, लेकिन थोड़ा तेज भी। उदाहरण के लिए, सीधे - 1m2.819s, कार्यक्रम के माध्यम से - 0m56.209s। एकमात्र स्पष्टीकरण यह है कि wget शायद एक धागे में काम करता है, और कार्यक्रम दो थ्रेड्स में स्थानीय और दूरस्थ सॉकेट से डेटा प्राप्त करता है, जो थोड़ा त्वरण दे सकता है। लेकिन, अंतर अभी भी कम से कम है, और शायद यह किसी अन्य मशीन या नेटवर्क पर दिखाई नहीं देगा, लेकिन मुख्य बात यह है कि यह हस्तांतरण प्रक्रिया के दौरान बहुत बड़े लॉग के निर्माण के बावजूद, कम से कम सीधे नहीं धीरे-धीरे काम करता है।

इसलिए, पायथन, एर्लैंग और गो पर इस तरह के कार्यक्रम के तीन विकल्पों में से, मुझे सबसे ज्यादा पसंद है।

यह मुझे गो में समानता के साथ एक अच्छा प्रयोग लग रहा था।

संबंधित पोस्ट

• Erlang'e पर टीसीपी / आईपी प्रॉक्सी
• Erlang'e पर बेहतर टीसीपी / आईपी प्रॉक्सी
• टीसीपी / आईपी कनेक्शन के बहुपरत डिबगर (पायथन में)

रिपोजिटरी लिंक

• जाओ
• Erlang
• अजगर

पुनश्च

वैसे, यदि एक जेविस्ट ने एक समान कार्यक्रम को शर्मिंदा किया (यदि संभव हो, जिसमें ग्रहण / आईडीईए / चींटी / मावेन / वसंत / लॉग 4 जे / आइवी और इतने पर की आवश्यकता नहीं है), तो तुलना करना बहुत दिलचस्प होगा। और दक्षता और गति के मामले में नहीं, बल्कि सुंदरता, लालित्य के संदर्भ में।