DuckCorp » CyborgHood

bot.stop(:quickly)

bot.stop(:quickly)

bot.stop(:quickly)

bot.stop(:quickly)

def stop(condition)

protected

# TODO: also wait for messages being processed to be finished (or try to interrupt cleanly if possible in :quickly condition)

bot.stop(:quickly)

bot.stop(:quickly)

#ask "MapMaker", :info1, "/_cyborg_"

#ask "Librarian", :info2, "/_cyborg_"

#ask "Librarian", :library, "/Records"

#ask "Librarian", :persons, "/Records/Persons"

#ask "Librarian", :gorou, "/Records/Persons/gorou"

#ask "Librarian", :guihome_net, "/Records/DnsDomains/guihome.net"

#ask "Librarian", :person_search, "/Records/Persons/?", {:uid => "g*"}

#ask "MapMaker", :search_master, "/Zones/?", {:is_master => true}

set_user "duck"

ask "Clerk", :dns_info, "/Commands/DNS/INFO"

stop_bot :quickly

#puts "Tadam: " + (results[:info1][:api_version] == results[:info2][:api_version] ? "same" : "different")

#set_preferred_locales "fr;q=1,en-us,en"

stop_bot :quickly

bot.stop(:quickly)

bot.stop(:quickly)

require 'thread'

def stop(condition)

case condition

when :when_finished

wait_until_ready_to_stop

when :quickly

# try to stop gracefully

DSL::Task.stop_all

wait_until_ready_to_stop

when :at_once

# it won't wait for anything to finish…

exit

end

# core capabilities

def capabilities

[]

end

protected

def stop_gracefully

def try_stop

def ready_to_stop?

DSL::Task.idle?

end

def wait_until_ready_to_stop

try_stop

EventMachine.next_tick { wait_until_ready_to_stop }

if @comm_list[peer].usuable?

logger.debug "Botnet: Reusing connection for peer #{peer}"

return block.call @comm_list[peer]

end

logger.debug "Botnet: conversation with '#{peer}' ready"

logger.debug "Botnet: conversation with '#{peer}' closed"

def stop(condition)

super do

@comm_list.each_value{|conv| conv.stop(condition) }

end

def send(go_quiet = false)

@conv_thread.conversation.send_message(self, go_quiet)

@comm_dead = false

@stop_when_finished = false

# ensure we go quiet

@message_send.synchronize do

@comm_stop = true

end

@comm_dead = true

def usuable?

not (@comm_dead or @comm_stop)

end

stop :quickly

end

def stop(condition)

case condition

when :when_finished

@stop_when_finished = true

when :quickly

@protocol.send_quit_leaving

end

return if @comm_stop

logger.debug "Conversation with '#{@peer_name}' on #{identifier} is closing"

# the block may use a <message>.send(true) to go quiet (set @comm_stop)

# ensure we go quiet

@message_send.synchronize do

@comm_stop = true

end

def send_message(message, quiet_after = false)

unless @comm_stop

send_line sprintf("%s-%04d-%04d%s %s", @bot.name, message.conv_thread.id, message.action_id, flags, message.action_code)

unless message.action_parameters.nil?

message.action_parameters.to_yaml.each_line {|l| send_line l }

send_line EOD

end

@comm_stop = true if quiet_after

return if @comm_stop

end

# test for idleness

if conv_thread.idle?

if @stop_when_finished

logger.debug "Thread '#{conv_thread.name}@#{@peer_name}' is currently idle, considered finished, closing"

close_thread(conv_thread.name)

return

end

logger.debug "Thread '#{conv_thread.name}@#{@peer_name}' is currently idle, doing another check in #{@auto_close_threads}s"

# send notification

@bot.get_channel(@system_notification_name) << {

:topic => 'THREAD IDLE',

:thread => conv_thread.name

}

@conv_threads_timers_manage.synchronize do

action_name = ['ask', cmd, *args].hash

_add_subtask_using_peer(action_name, peer) do |subtask, conv_thread|

action_name = ['know', cmd].hash

_add_subtask_using_peer(action_name, peer) do |subtask, conv_thread|

def _add_subtask_using_peer(action_name, peer)

subtask_name = "botnet/peer/#{peer}/#{action_name}/out"

_add_subtask(subtask_name) do |subtask|

# callback to end peer action and subtask

# (used when shooting the task)

defuse_peer_action_cb = Proc.new do

logger.debug "Task '#{@name}': defusing subtask '#{subtask.name}'"

subtask.finish unless subtask.finished?

# we already own the mutex here

registered_resources.delete(subtask_name)

end

# register peer action in the task

tasks_info_mutex.synchronize do

registered_resources[subtask_name] = defuse_peer_action_cb

end

logger.debug "Task '#{@name}': subtask '#{subtask.name}': peer '#{peer}' contacted, starting conversation"

# close opened thread

# loop on all contacted peers to close the thread

@conversation.thread('system').new_message("QUIT DECLINE", { :reason => reason }).send(true)

@conversation.thread('system').new_message("QUIT LEAVING").send(true)

# mutex used for all class variables in this paragraph

@@tasks_info_mutex = Mutex.new

@@registered_resources = {}

@@stop_all_tasks = false

@@tasks_info_mutex.synchronize do

@@task_wip == 0

end

end

def self.stop_all

@@stop_all_tasks = true

# call defuse callback out of the sync block

# (which may need to synchronize later to the

# same mutex in usual conditions)

resources_to_free = true

while not resources_to_free.nil?

@@tasks_info_mutex.synchronize do

resources_to_free = @@registered_resources.shift

end

resources_to_free[1].call unless resources_to_free.nil?

end

@@tasks_info_mutex.synchronize do

@@task_wip += 1

end

subtask_name = "notification/#{name}/#{criterias.hash}/in"

_add_subtask(subtask_name) do |subtask|

logger.debug "Task '#{@name}': subtask '#{subtask.name}': waiting notification on '#{name}'"

subcription_id = nil

subcription_id_mutex = Mutex.new

# callback to end notification and subtask

# (used when shooting the task)

defuse_notification_cb = Proc.new do

logger.debug "Task '#{@name}': defusing subtask '#{subtask.name}'"

subcription_id_mutex.synchronize do

@bot.get_channel(name).unsubscribe(subcription_id) unless subcription_id.nil?

subcription_id = nil

end

subtask.finish unless subtask.finished?

# we already own the mutex here

@@registered_resources.delete(subtask_name)

end

# register notification in the task

@@tasks_info_mutex.synchronize do

@@registered_resources[subtask_name] = defuse_notification_cb

end

if subtask.finished?

subcription_id_mutex.synchronize do

@bot.get_channel(name).unsubscribe(subcription_id) unless subcription_id.nil?

subcription_id = nil

end

# unregister the notification

@@tasks_info_mutex.synchronize do

@@registered_resources.delete(subtask_name)

end

end

subcription_id_mutex.synchronize do

@bot.get_channel(name).unsubscribe(subcription_id) unless subcription_id.nil?

subcription_id = nil

end

# unregister the notification

@@tasks_info_mutex.synchronize do

@@registered_resources.delete(subtask_name)

end

subtask_name = "timer/#{timeout}/#{cb.hash}"

_add_subtask(subtask_name) do |subtask|

timer_signature = nil

timer_signature_mutex = Mutex.new

# callback to end timer and subtask

# (used when shooting the task)

defuse_timer_cb = Proc.new do

logger.debug "Task '#{@name}': defusing subtask '#{subtask.name}'"

timer_signature_mutex.synchronize do

EventMachine.cancel_timer(timer_signature) unless timer_signature.nil?

timer_signature = nil

end

subtask.finish unless subtask.finished?

# we already own the mutex here

@@registered_resources.delete(subtask_name)

end

# register timer in the task

@@tasks_info_mutex.synchronize do

@@registered_resources[subtask_name] = defuse_timer_cb

end

timer_signature_mutex.synchronize do

if subtask.finished? and not timer_signature.nil?

EventMachine.cancel_timer(timer_signature)

timer_signature = nil

end

end

# unregister the timer

@@tasks_info_mutex.synchronize do

@@registered_resources.delete(subtask_name)

end

subtask.finish unless subtask.finished?

timer_signature = EventMachine.add_periodic_timer(timeout, timer_cb)

timer_signature = EventMachine.add_timer(timeout, timer_cb)

subtask.finish if meet_ok or @@stop_all_tasks

@bot.stop(condition)

raise CyberError.new(:unrecoverable, "botnet/client/dsl", "Task '#{@task.name}': subtask '#{@name}' should have ended, but it lied")

if @@stop_all_tasks

_finished

# running no more steps will end the task

return

end

@@tasks_info_mutex.synchronize do

@@task_wip -= 1

logger.debug "Task '#{@name}': finished (#{@@task_wip} tasks remaining)"

end

end

# needed for mixin

# TODO: find a cleaner solution

def tasks_info_mutex

@@tasks_info_mutex

end

# needed for mixin

# TODO: find a cleaner solution

def registered_resources

@@registered_resources