API tools faq
paste
Advertisement
Guest User

split

a guest
Oct 4th, 2018
190
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 17.63 KB | None | 0 0
raw download clone embed print report
  1.  
  2. # NOTA : quando si usa l'esacape \0... per il colore va staccato dalla variabile locale (dichiarata)
  3. # con set. Questo invece non vale per i parametri che vengono passati alla funzione all'interno
  4. # della stessa.
  5.  
  6. #Binds
  7.  
  8. # ===================================== COMANDI PUBBLICI ========================================
  9. bind pub -|- !splits pub:pubsplits
  10. bind pub -|- !splitswhy pub:pubreason
  11.  
  12. ###########################################################
  13. # lista dei canali su cui mostrare gli splits in pubblico #
  14. ###########################################################
  15. array set canali {
  16. "#tools"
  17. "#"
  18. }
  19.  
  20. proc pub:pubreason {nick uhost hand chan txt} {
  21. global reasonservers reasonsplit
  22. if {[array size reasonservers] != 0} {
  23. # putchan $chan "..:.:.. Motivi NETsplit ..:.:.."
  24. foreach reasonsplit [array names reasonservers] {
  25. putchan $chan "$reasonsplit "
  26. }
  27. } else {
  28. putchan $chan "$nick: No netsplit detected"
  29. }
  30. }
  31.  
  32. proc pub:pubsplits {nick uhost hand chan txt} {
  33. # canale per la notifica degli split
  34. # set canale "#hack.it"
  35. global sdservers sd_criticaltime canali
  36. # putchan $chan "..:.:.. NETsplit Status ..:.:.."
  37. # putchan $chan " "
  38. if {[array size sdservers] == 0} {
  39. putchan $chan "\[Netsplit] No netsplit detected"
  40. } else {
  41. foreach server [array names sdservers] {
  42. # questi sono i minuti calcolati se lo split dura meno di un ora !
  43. set splittime [expr [expr [unixtime] - $sdservers($server)] / 60]
  44. # Aggiunto da me #
  45. set splitseconds [expr [expr [expr ([unixtime]+0.0) - ($sdservers($server)+0.0)] / 60 ] - $splittime]
  46. set secondi [expr round([expr $splitseconds * 60]) ]
  47.  
  48. # nel caso lo split si prolunghi per piu' di un ora definisco ore minuti && secondi
  49. set ore [expr $splittime / 60]
  50. set mindouble [expr $splittime + 0.0 ]
  51. set minutidouble [expr fmod($mindouble,60.0) ]
  52. # questi sono i minuti calcolati nel caso di piu' di un'ora di split !
  53. set minuti [expr int($minutidouble) ]
  54.  
  55. # Se lo split e' critico . . .
  56. if {$splittime > $sd_criticaltime} { if {$splittime >= 60} { if {$ore == 1 && $minuti == 1 && $secondi == 1} { putchan $chan "${server} ($ore hrs $minuti mins $secondi secs) <= CRITICAL" }
  57.  
  58. if {$ore == 1 && $minuti == 1 && $secondi != 1} {putchan $chan "${server} ($ore hrs $minuti mins $secondi secs) <= CRITICAL"}
  59.  
  60. if {$ore == 1 && $minuti != 1 && $secondi == 1} {putchan $chan "${server} ($ore hrs $minuti mins $secondi secs) <= CRITICAL"}
  61.  
  62. if {$ore == 1 && $minuti != 1 && $secondi != 1} {putchan $chan "${server} ($ore hrs $minuti mins $secondi secs) <= CRITICAL"}
  63.  
  64. if {$ore != 1 && $minuti == 1 && $secondi == 1} {putchan $chan "${server} ($ore hrs $minuti mins $secondi secs) <= CRITICAL"}
  65.  
  66. if {$ore != 1 && $minuti == 1 && $secondi != 1} {putchan $chan "${server} ($ore hrs $minuti mins $secondi secs) <= CRITICAL"}
  67.  
  68. if {$ore != 1 && $minuti != 1 && $secondi == 1} {putchan $chan "${server} ($ore hrs $minuti mins $secondi secs) <= CRITICAL"}
  69.  
  70. if {$ore != 1 && $minuti != 1 && $secondi != 1} {putchan $chan "${server} ($ore hrs $minuti mins $secondi secs) <= CRITICAL"}
  71. }
  72. if { $splittime < 60 } {
  73. if {$secondi == 1} {putchan $chan "${server} (${splittime} mins $secondi secs) <= CRITICAL"}
  74. if {$secondi != 1} {putchan $chan "${server} (${splittime} mins $secondi secs) <= CRITICAL"}
  75.  
  76. # Se non e' critico (non c'e' bisogno del calcoro delle ore ) . . .
  77. } } else { if {$splittime == 1 && $secondi != 1} {putchan $chan "${server} (${splittime} mins $secondi secs)"}
  78. if {$splittime == 1 && $secondi == 1} {putchan $chan "${server} (${splittime} mins $secondi secs)"}
  79. # se i minuti sono > 1 (ma minori di un ora)
  80. if { $splittime != 0 && $splittime != 1 && $secondi != 1} {putchan $chan "${server} (${splittime} mins $secondi secs)"}
  81. if { $splittime != 0 && $splittime != 1 && $secondi == 1} {putchan $chan "${server} (${splittime} mins $secondi secs)"}
  82. # se sono 0 minuti tolgo la scritta minuti. . .
  83. if {$splittime == 0 && $secondi != 1} {putchan $chan "${server} ($secondi secs)"}
  84. if {$splittime == 0 && $secondi == 1} {putchan $chan "${server} ($secondi secs)"}
  85. }
  86. }
  87. }
  88. # putchan $chan "-----------------------------------------------"
  89. # putchan $chan "Totale : \0034[array size sdservers]\003 server in split."
  90. return 1
  91. }
  92.  
  93.  
  94. proc pub:split {server motivo} {
  95. # canale per la notifica degli split
  96. # set canale "#hack.it"
  97. # reasonservers e' un array : e' stato aggiunto da me x il reson degli splits
  98.  
  99. global sdservers sd_ignore sd_showall reasonservers reasonsplit canali
  100. set server [string tolower $server]
  101. if {[lsearch -exact $sd_ignore $server] > -1} {return 1}
  102.  
  103. foreach canale [array get canali] {
  104. if {$sd_showall} {putchan $canale "\[Netsplit] $motivo"}
  105. }
  106.  
  107. foreach splitserver [array names sdservers] {
  108. if {[string match $splitserver $server] || [string match $server $splitserver]} {
  109. putchan $canale "16hmm... Ti ho detto che $server e' gia' in split . . . resetto lo split-time"
  110. unset sdservers($splitserver)
  111. unset reasonservers($motivo)
  112. }
  113. }
  114. set sdservers($server) [unixtime]
  115. # aggiunto da me x il motivo degli splits
  116. set reasonsplit $motivo
  117. set reasonservers($reasonsplit) $reasonsplit
  118. }
  119.  
  120.  
  121. proc pub:rejoin {server} {
  122. # canale per la notifica degli split
  123. # set canale "#hack.it"
  124. global sdservers sd_showall sd_ignore sd_criticaltime reasonservers reasonsplit canali
  125. set server [string tolower $server]
  126. if {[lsearch -exact $sd_ignore $server] > -1} {return 1}
  127. set inarray 0
  128. foreach splitserver [array names sdservers] {
  129. if {[string match $splitserver $server] || [string match $server $splitserver]} {
  130. set inarray 1
  131. set splittime [expr [expr [unixtime] - $sdservers($splitserver)] / 60]
  132. # Aggiunto da me #
  133. set splitseconds [expr [expr [expr ([unixtime]+0.0) - ($sdservers($server)+0.0)] / 60 ] - $splittime]
  134. set secondi [expr round([expr $splitseconds * 60]) ]
  135. unset sdservers($splitserver)
  136. }
  137. }
  138.  
  139. ########## Aggiunto da me x i reason degli splits ##########
  140. # aggiunto da me la variabile servreason con gli * altrimenti non matcha la stringa . . .
  141. set servreason "*$server*"
  142. foreach reasonsplit [array names reasonservers] {
  143. if {[string match $reasonsplit $servreason] || [string match $servreason $reasonsplit]} {
  144. #aggiunto da me per gli split reason
  145. unset reasonservers($reasonsplit)
  146. }
  147. }
  148. ############################################################
  149.  
  150. foreach canale [array get canali] {
  151. if {!$inarray} {
  152. if {$sd_showall} {putchan $canale "\[Netsplit] $server reconnected"}
  153. } else {
  154. ####### MODIFICATO ########
  155. # Ho aggiunto un return 0 altrimenti al ritorno di chiamata di funzione esegue il controllo anche sugli altri if . . .
  156. if {$sd_showall} { if {$splittime > $sd_criticaltime} {pub:criticalreconnect $server $splittime $secondi
  157. return 0}
  158. if {$splittime == 1 && $secondi != 1} {putchan $canale "\[Netsplit] $server reconnected after ${splittime} mins ${secondi} secs"}
  159. if {$splittime == 1 && $secondi == 1} {putchan $canale "\[Netsplit] $server reconnected after ${splittime} mins ${secondi} secs"}
  160. # se i minuti sono > 1 . . .
  161. if { $splittime != 0 && $splittime != 1 && $secondi != 1} {putchan $canale "\[Netsplit] $server reconnected after ${splittime} mins ${secondi} secs"}
  162. if { $splittime != 0 && $splittime != 1 && $secondi == 1} {putchan $canale "\[Netsplit] $server reconnected after ${splittime} mins ${secondi} secs"}
  163. if {$splittime == 0 && $secondi != 1} {putchan $canale "\[Netsplit] $server reconnected after ${secondi} secs"}
  164. if {$splittime == 0 && $secondi == 1} {putchan $canale "\[Netsplit] $server reconnected after ${secondi} secs"}
  165.  
  166. }
  167. ############################
  168. }
  169. }
  170. }
  171.  
  172. #################### TEST ############################
  173. bind pub -|- !test pub:test
  174. bind msg -|- !test pub:test
  175. bind dcc o !test pub:test
  176. bind pub -|C !test2 pub:test2
  177. proc pub:test {nick uhost hand chan txt} {
  178. global reasonsplit reasonservers
  179. #foreach reasonsplit [array names reasonservers] {
  180. # if { [string match $reasonsplit $servero] || [string match $servero $reasonsplit ] } {
  181. #putchan $canale "Cancellato."
  182. # unset reasonservers($reasonsplit)
  183. # }
  184. #}
  185.  
  186. #putquick "JOIN #socio l1gn4n0"
  187.  
  188. }
  189. #################### TEST ############################
  190.  
  191. proc pub:criticalreconnect {server mins sec} {
  192. #set canale "#hack.it"
  193. global canali
  194.  
  195. # nel caso lo split si prolunghi per piu' di un ora
  196. set ore [expr $mins / 60]
  197. set mindouble [expr ${mins} + 0.0 ]
  198. set minutidouble [expr fmod($mindouble,60.0) ]
  199. set minuti [expr int($minutidouble) ]
  200. foreach canale [array get canali] {
  201. if {$mins >= 60} { if {$ore == 1 && $minuti == 1 && ${sec} == 1} { putchan $canale "\[Netsplit] $server reconnected after $ore hrs $minuti mins $sec secs" }
  202.  
  203. if {$ore == 1 && $minuti == 1 && $sec != 1} {putchan $canale "\[Netsplit] $server reconnected after $ore hrs $minuti mins $sec secs"}
  204.  
  205. if {$ore == 1 && $minuti != 1 && $sec == 1} {putchan $canale "\[Netsplit] $server reconnected after $ore hrs $minuti mins $sec secs"}
  206.  
  207. if {$ore == 1 && $minuti != 1 && $sec != 1} {putchan $canale "\[Netsplit] $server reconnected after $ore hrs $minuti mins $sec secs"}
  208.  
  209. if {$ore != 1 && $minuti == 1 && $sec == 1} {putchan $canale "\[Netsplit] $server reconnected after $ore hrs $minuti mins $sec secs"}
  210.  
  211. if {$ore != 1 && $minuti == 1 && $sec != 1} {putchan $canale "\[Netsplit] $server reconnected after $ore hrs $minuti mins $sec secs"}
  212.  
  213. if {$ore != 1 && $minuti != 1 && $sec == 1} {putchan $canale "\[Netsplit] $server reconnected after $ore hrs $minuti mins $sec secs"}
  214.  
  215. if {$ore != 1 && $minuti != 1 && $sec != 1} {putchan $canale "\[Netsplit] $server reconnected after $ore hrs $minuti mins $sec secs"}
  216.  
  217. }
  218.  
  219. if {$mins < 60} { if {$sec == 1} { putchan $canale "\[Netsplit] $server reconnected after $minuti mins $sec secs" }
  220. if {$sec != 1} { putchan $canale "\[Netsplit] $server reconnected after $minuti mins $sec secs" }
  221. }
  222. }
  223. putallbots "critrec"
  224.  
  225. }
  226.  
  227. proc pub:criticalsplit {server} {
  228. # set canale "#hack.it"
  229. global canali
  230. foreach canale [array get canali] {
  231. putchan $canale "\[Netsplit] $server <= CRITICAL"
  232. }
  233. }
  234. # ===================================== COMANDI PUBBLICI ========================================
  235.  
  236.  
  237.  
  238.  
  239.  
  240. # ===================================== COMANDI PRIVAT ========================================
  241. proc sd_helpidx {hand chan idx} {
  242. if {![matchattr $hand m $chan]} {return 0}
  243. putidx $idx "splitdetect.tcl commands"
  244. if {[matchattr $hand m]} {
  245. putidx $idx " For masters:"
  246. putidx $idx " netsplits"
  247. }
  248. putidx $idx " "
  249. return 1
  250. }
  251.  
  252. proc sd_help {hand chan idx cmd} {
  253. global sd_criticaltime sd_showall
  254. if {[matchattr $hand m|m $chan]} {
  255. switch -exact -- $cmd {
  256. "netsplits" {
  257. if {[matchattr $hand m]} {
  258. putidx $idx "# netsplits"
  259. if {$sd_showall} {
  260. putwrap $idx 3 "This command shows all splittet servers. If a splits continues for more then $sd_criticaltime minutes it'll be shown as critical."
  261. return 1
  262. } else {
  263. putwrap $idx 3 "This command shows all critical splittet servers (Servers which are splittet for more then $sd_criticaltime minutes are considered as critical)."
  264. return 1
  265. }
  266. }
  267. }
  268. }
  269. }
  270. return 0
  271. }
  272.  
  273. lappend nb_helpidx "sd_helpidx"
  274. set nb_help(netsplits) "sd_help"
  275.  
  276.  
  277.  
  278. proc utimerid {timerproc} {
  279. foreach timer [timers] {
  280. if {[lindex [lindex $timer 1] 0] == $timerproc} {return [lindex $timer 0]}
  281. }
  282. return -1
  283. }
  284.  
  285. if {![string match *sd:checkforcriticalservers* [timers]]} {timer 1 sd:checkforcriticalservers}
  286.  
  287. proc raw:splitdetect {from keyword rest} {
  288. global sd_ignore
  289. # aggiunto da me x gli splitsreason
  290. set motivo $rest
  291. set motivo [lrange $motivo 6 end]
  292. ###################################
  293. set rest [string tolower $rest]
  294. set rest [split $rest { }]
  295. if {[lindex $rest 0] != "&servers" && [lindex $rest 0] != "&services"} {return 0}
  296. set rest [lrange $rest 1 end]
  297. set rest [string range $rest 1 end]
  298. # aggiunto da me
  299. set servermotivo [lindex $rest 2]
  300. set servermotivo "\0034$servermotivo\003"
  301. append servermotivo " $motivo"
  302. # split &servers
  303. if {[string match "received squit *" $rest]} {
  304. # Tolto altrimenti il tempo riconnessione split non funge ! sd:split [lindex $rest 2]
  305. # String range e' stato aggiunto da me per il reason degli splits
  306. # MOTIVO (SERVER + MOTIVO) : es. *.de (Connection Reset By Peer)
  307. pub:split [lindex $rest 2] $servermotivo
  308. }
  309. # split &services (aggiunto da me per gli hub splits)
  310. #if {[string match "received quit map@*" $rest]} {
  311. # Received QUIT map@TU-Ilmenau.DE from map@TU-Ilmenau.DE (BelWue.DE TU-Ilmenau.DE)
  312. # Received QUIT NoteServ@fu-berlin.de from NoteServ@fu-berlin.de (BelWue.DE Uni-Erlangen.DE)
  313. # set serv [lindex $rest 2]
  314. # set lung [string length $serv]
  315. # set serv [string range $serv 4 $lung]
  316. # pub:split $serv "Ping Timeout"
  317. # putchan "#drepanum" "serv : $serv - reason : Ping Timeout"
  318. #}
  319.  
  320. #if {[string match "received quit noteserv@*" $rest]} {
  321. # Received QUIT map@TU-Ilmenau.DE from map@TU-Ilmenau.DE (BelWue.DE TU-Ilmenau.DE)
  322. # Received QUIT NoteServ@fu-berlin.de from NoteServ@fu-berlin.de (BelWue.DE Uni-Erlangen.DE)
  323. # set serv [lindex $rest 2]
  324. # set lung [string length $serv]
  325. # set serv [string range $serv 9 $lung]
  326. ############ DEBUG #################
  327. # pub:split "$serv" "Ping Timeout"
  328. # putchan "#drepanum" "serv : $serv - reason : Ping Timeout"
  329. #}
  330.  
  331. if {[string match "received server *" $rest]} {
  332. ## Tolto altrimenti il tempo riconnessione split non funge ! sd:rejoin [lindex $rest 2]
  333. pub:rejoin [lindex $rest 2]
  334. }
  335.  
  336. # split &services (aggiunto da me per gli hub splits al rejoin)
  337. #if {[string match "received service map@*" $rest]} {
  338. # set serv [lindex $rest 2]
  339. # set lung [string length $serv]
  340. # set serv [string range $serv 4 $lung]
  341. # pub:rejoin $serv
  342. # }
  343.  
  344.  
  345. #if {[string match "received service NoteServ@*" $rest]} {
  346. # set serv [lindex $rest 2]
  347. # set lung [string length $serv]
  348. # set serv [string range $serv 9 $lung]
  349. # pub:rejoin $serv
  350. #}
  351.  
  352. }
  353.  
  354. proc sd:split {server} {
  355. global sdservers sd_ignore sd_showall reasonservers reasonsplit
  356. set server [string tolower $server]
  357. if {[lsearch -exact $sd_ignore $server] > -1} {return 1}
  358. if {$sd_showall} {putlog "Netsplit detected: $server"}
  359. foreach splitserver [array names sdservers] {
  360. if {[string match $splitserver $server] || [string match $server $splitserver]} {
  361. putlog "hmmz... I though $server is already splitted... reseting split-time"
  362. unset sdservers($splitserver)
  363. unset reasonservers($reasonsplit)
  364. }
  365. }
  366. set sdservers($server) [unixtime]
  367. }
  368.  
  369. proc sd:rejoin {server} {
  370. global sdservers sd_showall sd_ignore sd_criticaltime reasonservers reasonsplit
  371. set server [string tolower $server]
  372. if {[lsearch -exact $sd_ignore $server] > -1} {return 1}
  373. set inarray 0
  374. foreach splitserver [array names sdservers] {
  375. if {[string match $splitserver $server] || [string match $server $splitserver]} {
  376. set inarray 1
  377. set splittime [expr [expr [unixtime] - $sdservers($splitserver)] / 60]
  378. unset sdservers($splitserver)
  379. unset reasonservers($reasonsplit)
  380. }
  381. }
  382. if {!$inarray} {
  383. if {$sd_showall} {putlog "Reconnect detected: $server (unknown splittime)"}
  384. } else {
  385. if {$sd_showall} {putlog "Reconnect detected: $server (${splittime}min)"}
  386. if {$splittime > $sd_criticaltime} {pub:criticalreconnect $server $splittime}
  387. }
  388. }
  389.  
  390. # DISATTIVATI
  391.  
  392. # proc sd:criticalreconnect {server mins} {
  393. # putlog "$server reconnected after ${mins}min"
  394. # putallbots "critrec"
  395. # }
  396.  
  397. # proc sd:criticalsplit {server} {
  398. # putlog "Critical split detected: $server"
  399. # }
  400.  
  401. proc dcc:netsplits {hand idx rest} {
  402. global sdservers sd_criticaltime
  403. putdcc $idx "Current Netsplits:"
  404. putdcc $idx "---"
  405. if {[array size sdservers] == 0} {
  406. putdcc $idx "none ^_^"
  407. } else {
  408. foreach server [array names sdservers] {
  409. set splittime [expr [expr [unixtime] - $sdservers($server)] / 60]
  410. if {$splittime > $sd_criticaltime} {
  411. putdcc $idx "${server}(${splittime}min) <=== CRITICAL!"
  412. } else {
  413. putdcc $idx "${server}(${splittime}min)"
  414. }
  415. }
  416. }
  417. putdcc $idx "---"
  418. putdcc $idx "[array size sdservers] servers splitted"
  419. return 1
  420. }
  421.  
  422. proc sd:checkforcriticalservers {} {
  423. global sdservers sd_lost sd_criticaltime reasonservers reasonsplit
  424. foreach server [array names sdservers] {
  425. set splittime [expr [expr [unixtime] - $sdservers($server)] / 60]
  426. if {$splittime == $sd_criticaltime} {pub:criticalsplit $server}
  427. if {$splittime > $sd_lost} {
  428. putlog "Seems that $server got lost in the netsplit..."
  429. unset sdservers($server)
  430. unset reasonservers($reasonsplit)
  431. }
  432. }
  433. if {![string match *sd:checkforcriticalservers* [timers]]} {timer 1 sd:checkforcriticalservers}
  434. }
  435.  
  436. proc bot:critrec {bot command rest} {
  437. #putlog "$bot told me that there's a reconnect after a critical split."
  438. }
  439.  
  440. proc 001:joinservers {from keyword rest} {
  441. putquick "JOIN &servers"
  442. # questo canale mi serve per gli split da notificare sugli hub
  443. putquick "JOIN &services"
  444. return 0
  445. }
  446.  
  447. proc JOIN:joinservers {from keyword rest} {
  448. if {$rest == ":&servers"} {return 1} else {return 0}
  449. }
  450.  
  451.  
  452.  
  453.  
  454. bind dcc m netsplits dcc:netsplits
  455. bind raw - NOTICE raw:splitdetect
  456. bind raw - 001 001:joinservers
  457. bind raw - JOIN JOIN:joinservers
  458. bind bot - critrec bot:critrec
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!