updates

Author: bradennapier

.DS_Store

@@ -8,30 +8,37 @@
     # Get information about the requester from the protocol
     set proto      [ my protocol $protocol ]
     set descriptor [ $proto descriptor $chanID ]
-    
-    if { [dict get $CONFIG remote] == 0 } {
-      # When we have defined that we only wish to work with local scripts, we will 
+
+    if { [string is false -strict [dict get $CONFIG remote]] } {
+      # When we have defined that we only wish to work with local scripts, we will
       # check and immediately ignore any data received from outside the localhost
       if { ! [dict exists $descriptor local] } {
-        if { ! [my is_local [dict get $descriptor address]] } { 
-          return 
-        } else { dict set descriptor local 1 }
+        if { ! [my is_local [dict get $descriptor address]] } {
+          puts "Received from Non Local Source: $descriptor"
+          puts [::cluster::packet::decode $packet [self]]
+          return
+        } else {
+          dict set descriptor local 1
+        }
       } else {
-        if { ! [dict get $descriptor local] } { return }
+        if { ! [dict get $descriptor local] } {
+          puts "Received from Non Local Source: $descriptor"
+          puts [::cluster::packet::decode $packet [self]]
+          return
+        }
       }
     }
-    
-    # Attempt to decode the received packet.  
+
+    # Attempt to decode the received packet.
     # An empty payload will be returned if we fail to decode the packet for any reason.
     set payloads           [::cluster::packet::decode $packet [self]]
     set payloads_remaining [llength $payloads]
-    
+
     foreach payload $payloads {
       if { $payload eq {} || ! [dict exists $payload sid] || [dict get $payload sid] eq $SERVICE_ID } {
         # Ignore empty payloads or payloads that we receive from ourselves.
         return
       }
-      #puts "rx | $protocol"
       # Are we currently listening to the channel that the communication was
       # received on?
       if { [dict get $payload channel] ni $COMM_CHANNELS } {
@@ -41,17 +48,17 @@
       # Called before anything is done with the received payload but after it is
       # decoded. $payload may be modified if necessary before it is further evaluated.
       try {my run_hook evaluate receive} on error {r} { return }
-      
+
       try {my run_hook channel [dict get $payload channel] receive} on error {r} { return }
-      
+
       #lassign $payload type rchan op ruid system_id service_id protocols flags data
-      
+
       # Provide the data to the matching service to handle and parse.  Create the
-      # service if it does not exist.  
+      # service if it does not exist.
       # - If we receive an empty value in return, the received data has been rejected.
       set service [my service $proto $chanID $payload $descriptor]
       if { $service eq {} } { return }
-      
+
       set protocol [$proto proto]
       if { $protocol ne "c" } {
         my event channel receive $proto $chanID $service
@@ -66,7 +73,7 @@
 }
 
 # A filter is a list of services which should parse / receive the given payload.
-# It is used as an insecure way of routing broadcasted data to specific clients 
+# It is used as an insecure way of routing broadcasted data to specific clients
 # When we have not yet created a channel.  For example, it can be useful to request
 # a group of clients to join a specific channel.
 ::oo::define ::cluster::cluster method check_filter { filter } {
@@ -78,39 +85,39 @@
 }
 
 # Whenever we receive data, we will check to see if the service already exists
-# within our cache.  If it does, we will return a reference to the service.  If 
-# it doesn't, we will create it then return its reference. 
+# within our cache.  If it does, we will return a reference to the service.  If
+# it doesn't, we will create it then return its reference.
 #
-# If a service should not be allowed to communicate with us, we will return an 
+# If a service should not be allowed to communicate with us, we will return an
 # empty string at which point the command should cease to parse the received
 # payload immediately.
 ::oo::define ::cluster::cluster method service { proto chanID payload descriptor } {
   set system_id  [dict get $payload hid]
   set service_id [dict get $payload sid]
-  
+
   # Added Security - if the system id does not match, we dont parse it when only
   # accepting local.
   if { [dict get $CONFIG remote] == 0 && $system_id ne $SYSTEM_ID } { return }
-  
+
   set uuid ${service_id}@${system_id}
-  
+
   set service ${NS}::services::$uuid
-  
+
   set serviceExists [expr { [info commands $service] ne {} }]
-  
+
   # Call our service eval hook
   try {my run_hook evaluate service} on error {r} { return }
-  
+
   if { [string is true $serviceExists] } {
     # If our service already exists, we will validate it against the
     # received data to determine if we want to allow communication
-    # with the service.  If we validate, then we will return the 
+    # with the service.  If we validate, then we will return the
     # reference to the service to our handler.
     try {my run_hook service validate} on error {r} { return }
     if { [$service validate $proto $chanID $payload $descriptor] } { return $service }
   } else {
     # If we have never seen this service, we will create it.  We will check
-    # it against our security policies and retain it if it is a service we 
+    # it against our security policies and retain it if it is a service we
     # are allowed to communicate with.  Otherwise it will be destroyed.
     try {
       set service [::cluster::service create $service [self] $proto $chanID $payload $descriptor]

classes/cluster/cluster-rx.tcl

@@ -1,9 +1,9 @@
 # Broadcast to the cluster.  This is a shortcut to send to the cluster protocol.
 ::oo::define ::cluster::cluster method broadcast { payload } {
   try {
-    set proto [dict get $PROTOCOLS c] 
+    set proto [dict get $PROTOCOLS c]
     try {my run_hook broadcast} on error {r} { return 0 }
-    try {my run_hook channel [dict get $payload channel] send} on error {r} { return 0 } 
+    try {my run_hook channel [dict get $payload channel] send} on error {r} { return 0 }
     return [ $proto send [::cluster::packet::encode $payload] ]
   } on error {result options} {
     ::onError $result $options "While Broadcasting a Cluster Payload" $payload
@@ -23,7 +23,7 @@
       set props [lsort -unique [concat $UPDATED_PROPS $props]]
       set UPDATED_PROPS [list]
       my CheckServices
-      my CheckProtocols 
+      my CheckProtocols
     }
     if { "tags" in $props } { set tags 1 }
     my broadcast [my heartbeat_payload $props $tags $channel]
@@ -33,7 +33,7 @@
 }
 
 # Reschedule the heartbeat so that it will occur after the given time.  This is useful
-# for when we want to cause a heartbeat to occur sooner than the normal time but dont 
+# for when we want to cause a heartbeat to occur sooner than the normal time but dont
 # want to accidentally dispatch tons of heartbeats when multiple services call it, etc.
 ::oo::define ::cluster::cluster method heartbeat_after { ms } {
   try {
@@ -46,7 +46,7 @@
 
 
 # Send a discovery probe to the cluster.  Each service will send its response
-# based on the best protocol it can find. 
+# based on the best protocol it can find.
 ::oo::define ::cluster::cluster method discover { {ruid {}} {channel 0} } {
   my variable LAST_DISCOVERY
   if { ! [info exists LAST_DISCOVERY] } { set LAST_DISCOVERY [clock seconds] } else {
@@ -81,39 +81,39 @@
     lappend services {*}[my resolver [dict get $args -resolver]]
   }
   if { [dict exists $args -resolve] } {
-    # Resolve the given list. 
+    # Resolve the given list.
     lappend services {*}[my resolve [dict get $args -resolve]]
   }
-  
+
   #puts "Send to services [llength $services]"
   #puts $services
   set allow_broadcast 0
-  
+
   if { [dict exists $args -broadcast] } {
     # 1 / 0 - Indicates if we want to broadcast the message or not.
     # If empty we will try to decide automatically.
     set broadcast [dict get $args -broadcast]
     if { $broadcast eq {} } { set allow_broadcast 1 }
-  } else { 
+  } else {
     # When broadcast is empty we are indicating that we are not yet
     # sure if we want to broadcast the message.
-    set broadcast {} 
-    # When we have not explicitly turned broadcasting off then we 
+    set broadcast {}
+    # When we have not explicitly turned broadcasting off then we
     # will allow it to be used as a last resort if all other protocols
     # fail.  The broadcast will be filtered so only the given service
     # will respond.
     set allow_broadcast 1
   }
 
   if { ! [string is true -strict $broadcast] } {
-    if { $services eq {} } { return } 
+    if { $services eq {} } { return }
   }
-  
+
   if { [dict exists $args -protocols] } {
     set protocols [dict get $args -protocols]
   } else {
     # If protocols isnt provided - we need to determine the
-    # best way to send our message based on the number of 
+    # best way to send our message based on the number of
     # services that have been resolved.
     #
     # Right now we keep it simple - more than 3 we use cluster
@@ -136,29 +136,29 @@
       set broadcast 0
     }
   }
-  
+
   if { [dict exists $args -channel] } {
-    set channel [dict get $args -channel] 
+    set channel [dict get $args -channel]
   } else { set channel 0 }
-  
+
   if { [dict exists $args -ruid] } {
-    dict set request ruid [dict get $args -ruid] 
+    dict set request ruid [dict get $args -ruid]
   }
-  
+
   if { [dict exists $args -data] } {
-    dict set request data [dict get $args -data] 
+    dict set request data [dict get $args -data]
   }
-  
+
   # Make sure we only have one of each service
   set services [lsort -unique $services]
-  
+
   if { [string is true -strict $broadcast] && $services ne {} } {
     # If we are using the cluster protocol to transmit, we use broadcast
     # to send our payload.  This means that we also need to add a filter
-    # to the request so that only our desired services will handle the 
-    # message being sent.  
+    # to the request so that only our desired services will handle the
+    # message being sent.
     #
-    # A filter will be automatically applied when sending directly to 
+    # A filter will be automatically applied when sending directly to
     # a service otherwise.
     #
     # This allows us to use the multicast as a p2p connection to aid in
@@ -169,9 +169,9 @@
     }
     dict set request filter $filter
   }
-  
+
   set payload [my event_payload $request $channel]
-  
+
   if { [string is true -strict $broadcast] } {
     # We have indicated that we want to broadcast the message.
     my broadcast $payload
@@ -181,36 +181,37 @@
     # as we will attempt to handle it ourselves if required.
     set response [ my send_payload $services $payload $protocols 0 ]
     if { $response eq {} } {
-      # We will receive an empty response when a hook has cancelled the 
+      # We will receive an empty response when a hook has cancelled the
       # transmission
     } else {
       lassign $response success failed
       # puts stderr "Success: $success"
-      
+
       if { $failed ne {} } {
         #puts stderr "Failed:  $failed"
         # If we failed to send to any services we will determine how we should
         # proceed.
         # ::utils::flog "Failed to Send To Cluster Services \n $args \n $failed"
         # ~! "Cluster Warning" "Failed to send to Cluster Services" \
         #   -context "
-        #     Success: 
+        #     Success:
         #     $success
         #     ------------
-        #     Failed: 
+        #     Failed:
         #     $failed
         #   "
       }
     }
   }
-  # Return a resolved list of the services and payload being used.  This way 
+  # Return a resolved list of the services and payload being used.  This way
   # multiple requests can simply call send_payload directly without running
   # through this process.
   return [list $services $payload $protocols]
 }
 
 ::oo::define ::cluster::cluster method send_payload { services payload protocols {allow_broadcast 0} } {
   set success [dict create] ; set failed [dict create]
+
   try {my run_hook channel [dict get $payload channel] send} on error { r } { return }
   foreach service $services {
     try {
@@ -225,4 +226,4 @@
     }
   }
   return [list $success $failed]
-}
+}