Datasets:

---

CM

/

codexglue_code2text_ruby

like 1

[ "def", "related", "(", "url", ",", "options", "=", "{", "}", ")", "response", "=", "handle_response", "(", "get", "(", "\"/related.json\"", ",", ":query", "=>", "{", ":url", "=>", "url", "}", ".", "merge", "(", "options", ")", ")", ")", "Topsy", "::", "Page", ".", "new", "(", "response", ",", "Topsy", "::", "LinkSearchResult", ")", "end" ]

[ "Returns", "list", "of", "URLs", "related", "to", "a", "given", "URL" ]

[ "def", "search", "(", "q", ",", "options", "=", "{", "}", ")", "if", "q", ".", "is_a?", "(", "Hash", ")", "options", "=", "q", "q", "=", "\"site:#{options.delete(:site)}\"", "if", "options", "[", ":site", "]", "else", "q", "+=", "\" site:#{options.delete(:site)}\"", "if", "options", "[", ":site", "]", "end", "options", "=", "set_window_or_default", "(", "options", ")", "results", "=", "handle_response", "(", "get", "(", "\"/search.json\"", ",", ":query", "=>", "{", ":q", "=>", "q", "}", ".", "merge", "(", "options", ")", ")", ")", "Topsy", "::", "Page", ".", "new", "(", "results", ",", "Topsy", "::", "LinkSearchResult", ")", "end" ]

[ "Returns", "list", "of", "results", "for", "a", "query", "." ]

[ "def", "search_count", "(", "q", ")", "counts", "=", "handle_response", "(", "get", "(", "\"/searchcount.json\"", ",", ":query", "=>", "{", ":q", "=>", "q", "}", ")", ")", "Topsy", "::", "SearchCounts", ".", "new", "(", "counts", ")", "end" ]

[ "Returns", "count", "of", "results", "for", "a", "search", "query", "." ]

[ "def", "search_histogram", "(", "q", ",", "count_method", "=", "'target'", ",", "slice", "=", "86400", ",", "period", "=", "30", ")", "response", "=", "handle_response", "(", "get", "(", "\"/searchhistogram.json\"", ",", ":query", "=>", "{", ":q", "=>", "q", ",", ":slice", "=>", "slice", ",", ":period", "=>", "period", ",", ":count_method", "=>", "count_method", "}", ")", ")", "Topsy", "::", "SearchHistogram", ".", "new", "(", "response", ")", "end" ]

[ "Returns", "mention", "count", "data", "for", "the", "given", "query" ]

[ "def", "stats", "(", "url", ",", "options", "=", "{", "}", ")", "query", "=", "{", ":url", "=>", "url", "}", "query", ".", "merge!", "(", "options", ")", "response", "=", "handle_response", "(", "get", "(", "\"/stats.json\"", ",", ":query", "=>", "query", ")", ")", "Topsy", "::", "Stats", ".", "new", "(", "response", ")", "end" ]

[ "Returns", "counts", "of", "tweets", "for", "a", "URL" ]

[ "def", "tags", "(", "url", ",", "options", "=", "{", "}", ")", "response", "=", "handle_response", "(", "get", "(", "\"/tags.json\"", ",", ":query", "=>", "{", ":url", "=>", "url", "}", ".", "merge", "(", "options", ")", ")", ")", "Topsy", "::", "Page", ".", "new", "(", "response", ",", "Topsy", "::", "Tag", ")", "end" ]

[ "Returns", "list", "of", "tags", "for", "a", "URL", "." ]

[ "def", "trending", "(", "options", "=", "{", "}", ")", "response", "=", "handle_response", "(", "get", "(", "\"/trending.json\"", ",", ":query", "=>", "options", ")", ")", "Topsy", "::", "Page", ".", "new", "(", "response", ",", "Topsy", "::", "Trend", ")", "end" ]

[ "Returns", "list", "of", "trending", "terms" ]

[ "def", "url_info", "(", "url", ")", "response", "=", "handle_response", "(", "get", "(", "\"/urlinfo.json\"", ",", ":query", "=>", "{", ":url", "=>", "url", "}", ")", ")", "Topsy", "::", "UrlInfo", ".", "new", "(", "response", ")", "end" ]

[ "Returns", "info", "about", "a", "URL" ]

[ "def", "extract_header_value", "(", "response", ",", "key", ")", "response", ".", "headers", "[", "key", "]", ".", "class", "==", "Array", "?", "response", ".", "headers", "[", "key", "]", ".", "first", ".", "to_i", ":", "response", ".", "headers", "[", "key", "]", ".", "to_i", "end" ]

[ "extracts", "the", "header", "key" ]

[ "def", "poll_again", "(", "fiber", ",", "connection", ",", "request_options", ",", "stop_at", ")", "http", "=", "connection", ".", "send", "(", ":get", ",", "request_options", ")", "http", ".", "errback", "{", "fiber", ".", "resume", "(", "handle_error", "(", "\"POLL\"", ",", "http", ".", "error", ")", ")", "}", "http", ".", "callback", "do", "code", ",", "body", ",", "headers", "=", "http", ".", "response_header", ".", "status", ",", "http", ".", "response", ",", "http", ".", "response_header", "if", "code", "==", "200", "&&", "(", "body", ".", "nil?", "||", "body", "==", "\"null\"", ")", "&&", "Time", ".", "now", "<", "stop_at", "poll_again", "(", "fiber", ",", "connection", ",", "request_options", ",", "stop_at", ")", "else", "fiber", ".", "resume", "(", "code", ",", "body", ",", "headers", ")", "end", "end", "true", "end" ]

[ "Repeatedly", "make", "long", "-", "polling", "request", "until", "receive", "data", "hit", "error", "or", "timeout", "Treat", "terminating", "and", "reconnecting", "errors", "as", "an", "empty", "poll", "result" ]

[ "def", "beautify_headers", "(", "headers", ")", "headers", ".", "inject", "(", "{", "}", ")", "{", "|", "out", ",", "(", "key", ",", "value", ")", "|", "out", "[", "key", ".", "gsub", "(", "/", "/", ",", "'_'", ")", ".", "downcase", ".", "to_sym", "]", "=", "value", ";", "out", "}", "end" ]

[ "Beautify", "response", "header", "keys", "so", "that", "in", "same", "form", "as", "RestClient" ]

[ "def", "tags", "(", "options", "=", "{", "}", ")", "# TODO remove use of agent identity when fully drop AMQP", "do_query", "(", "nil", ",", "@agent", ".", "mode", "==", ":http", "?", "@agent", ".", "self_href", ":", "@agent", ".", "identity", ",", "options", ")", "do", "|", "result", "|", "if", "result", ".", "kind_of?", "(", "Hash", ")", "yield", "(", "result", ".", "size", "==", "1", "?", "result", ".", "values", ".", "first", "[", "'tags'", "]", ":", "[", "]", ")", "else", "yield", "result", "end", "end", "end" ]

[ "Retrieve", "current", "agent", "tags", "and", "give", "result", "to", "block" ]

[ "def", "query_tags", "(", "tags", ",", "options", "=", "{", "}", ")", "tags", "=", "ensure_flat_array_value", "(", "tags", ")", "unless", "tags", ".", "nil?", "||", "tags", ".", "empty?", "do_query", "(", "tags", ",", "nil", ",", "options", ")", "{", "|", "result", "|", "yield", "result", "}", "end" ]

[ "Queries", "a", "list", "of", "servers", "in", "the", "current", "deployment", "which", "have", "one", "or", "more", "of", "the", "given", "tags", "." ]

[ "def", "add_tags", "(", "new_tags", ",", "options", "=", "{", "}", ")", "new_tags", "=", "ensure_flat_array_value", "(", "new_tags", ")", "unless", "new_tags", ".", "nil?", "||", "new_tags", ".", "empty?", "do_update", "(", "new_tags", ",", "[", "]", ",", "options", ")", "{", "|", "raw_response", "|", "yield", "raw_response", "if", "block_given?", "}", "end" ]

[ "Add", "given", "tags", "to", "agent" ]

[ "def", "remove_tags", "(", "old_tags", ",", "options", "=", "{", "}", ")", "old_tags", "=", "ensure_flat_array_value", "(", "old_tags", ")", "unless", "old_tags", ".", "nil?", "||", "old_tags", ".", "empty?", "do_update", "(", "[", "]", ",", "old_tags", ",", "options", ")", "{", "|", "raw_response", "|", "yield", "raw_response", "if", "block_given?", "}", "end" ]

[ "Remove", "given", "tags", "from", "agent" ]

[ "def", "do_query", "(", "tags", "=", "nil", ",", "hrefs", "=", "nil", ",", "options", "=", "{", "}", ")", "raw", "=", "options", "[", ":raw", "]", "timeout", "=", "options", "[", ":timeout", "]", "request_options", "=", "{", "}", "request_options", "[", ":timeout", "]", "=", "timeout", "if", "timeout", "agent_check", "payload", "=", "{", ":agent_identity", "=>", "@agent", ".", "identity", "}", "payload", "[", ":tags", "]", "=", "ensure_flat_array_value", "(", "tags", ")", "unless", "tags", ".", "nil?", "||", "tags", ".", "empty?", "# TODO remove use of agent identity when fully drop AMQP", "if", "@agent", ".", "mode", "==", ":http", "payload", "[", ":hrefs", "]", "=", "ensure_flat_array_value", "(", "hrefs", ")", "unless", "hrefs", ".", "nil?", "||", "hrefs", ".", "empty?", "else", "payload", "[", ":agent_ids", "]", "=", "ensure_flat_array_value", "(", "hrefs", ")", "unless", "hrefs", ".", "nil?", "||", "hrefs", ".", "empty?", "end", "request", "=", "RightScale", "::", "RetryableRequest", ".", "new", "(", "\"/router/query_tags\"", ",", "payload", ",", "request_options", ")", "request", ".", "callback", "{", "|", "result", "|", "yield", "raw", "?", "request", ".", "raw_response", ":", "result", "}", "request", ".", "errback", "do", "|", "message", "|", "ErrorTracker", ".", "log", "(", "self", ",", "\"Failed to query tags (#{message})\"", ")", "yield", "(", "(", "raw", "?", "request", ".", "raw_response", ":", "nil", ")", "||", "message", ")", "end", "request", ".", "run", "true", "end" ]

[ "Runs", "a", "tag", "query", "with", "an", "optional", "list", "of", "tags", "." ]

[ "def", "do_update", "(", "new_tags", ",", "old_tags", ",", "options", "=", "{", "}", ",", "&", "block", ")", "agent_check", "raise", "ArgumentError", ".", "new", "(", "\"Cannot add and remove tags in same update\"", ")", "if", "new_tags", ".", "any?", "&&", "old_tags", ".", "any?", "tags", "=", "@agent", ".", "tags", "tags", "+=", "new_tags", "tags", "-=", "old_tags", "tags", ".", "uniq!", "if", "new_tags", ".", "any?", "request", "=", "RightScale", "::", "RetryableRequest", ".", "new", "(", "\"/router/add_tags\"", ",", "{", ":tags", "=>", "new_tags", "}", ",", "options", ")", "elsif", "old_tags", ".", "any?", "request", "=", "RightScale", "::", "RetryableRequest", ".", "new", "(", "\"/router/delete_tags\"", ",", "{", ":tags", "=>", "old_tags", "}", ",", "options", ")", "else", "return", "end", "if", "block", "# Always yield raw response", "request", ".", "callback", "do", "|", "_", "|", "# Refresh agent's copy of tags on successful update", "@agent", ".", "tags", "=", "tags", "block", ".", "call", "(", "request", ".", "raw_response", ")", "end", "request", ".", "errback", "{", "|", "message", "|", "block", ".", "call", "(", "request", ".", "raw_response", "||", "message", ")", "}", "end", "request", ".", "run", "true", "end" ]

[ "Runs", "a", "tag", "update", "with", "a", "list", "of", "new", "or", "old", "tags" ]

[ "def", "init", "(", "agent", ",", "agent_name", ",", "options", "=", "{", "}", ")", "@agent", "=", "agent", "@trace_level", "=", "options", "[", ":trace_level", "]", "||", "{", "}", "notify_init", "(", "agent_name", ",", "options", ")", "reset_stats", "true", "end" ]

[ "Initialize", "error", "tracker" ]

[ "def", "log", "(", "component", ",", "description", ",", "exception", "=", "nil", ",", "packet", "=", "nil", ",", "trace", "=", "nil", ")", "if", "exception", ".", "nil?", "Log", ".", "error", "(", "description", ")", "elsif", "exception", ".", "is_a?", "(", "String", ")", "Log", ".", "error", "(", "description", ",", "exception", ")", "else", "trace", "=", "(", "@trace_level", "&&", "@trace_level", "[", "exception", ".", "class", "]", ")", "||", "trace", "||", ":trace", "Log", ".", "error", "(", "description", ",", "exception", ",", "trace", ")", "track", "(", "component", ",", "exception", ",", "packet", ")", "if", "trace", "!=", ":no_trace", "end", "true", "rescue", "StandardError", "=>", "e", "Log", ".", "error", "(", "\"Failed to log error\"", ",", "e", ",", ":trace", ")", "rescue", "nil", "false", "end" ]

[ "Log", "error", "and", "optionally", "track", "in", "stats", "Errbit", "notification", "is", "left", "to", "the", "callback", "configured", "in", "the", "stats", "tracker", "Logging", "works", "even", "if", "init", "was", "never", "called" ]

[ "def", "track", "(", "component", ",", "exception", ",", "packet", "=", "nil", ")", "if", "@exception_stats", "component", "=", "component", ".", "class", ".", "name", ".", "split", "(", "\"::\"", ")", ".", "last", ".", "snake_case", "unless", "component", ".", "is_a?", "(", "String", ")", "@exception_stats", ".", "track", "(", "component", ",", "exception", ",", "packet", ")", "end", "true", "end" ]

[ "Track", "error", "in", "stats" ]

[ "def", "notify", "(", "exception", ",", "packet", "=", "nil", ",", "agent", "=", "nil", ",", "component", "=", "nil", ")", "if", "@notify_enabled", "if", "packet", "&&", "packet", ".", "is_a?", "(", "Packet", ")", "action", "=", "packet", ".", "type", ".", "split", "(", "\"/\"", ")", ".", "last", "if", "packet", ".", "respond_to?", "(", ":type", ")", "params", "=", "packet", ".", "respond_to?", "(", ":payload", ")", "&&", "packet", ".", "payload", "uuid", "=", "packet", ".", "respond_to?", "(", ":token", ")", "&&", "packet", ".", "token", "elsif", "packet", ".", "is_a?", "(", "Hash", ")", "action_path", "=", "packet", "[", ":path", "]", "||", "packet", "[", "\"path\"", "]", "action", "=", "action_path", ".", "split", "(", "\"/\"", ")", ".", "last", "if", "action_path", "params", "=", "packet", "[", ":data", "]", "||", "packet", "[", "\"data\"", "]", "uuid", "=", "packet", "[", ":uuid", "]", "||", "packet", "[", "\"uuid\"", "]", "else", "params", "=", "uuid", "=", "nil", "end", "component", "=", "component", ".", "class", ".", "name", "unless", "component", ".", "is_a?", "(", "String", ")", "n", "=", "Airbrake", ".", "build_notice", "(", "exception", ",", "{", "component", ":", "component", ",", "action", ":", "action", "}", ",", ":right_agent", ")", "n", "[", ":params", "]", "=", "params", ".", "is_a?", "(", "Hash", ")", "?", "filter", "(", "params", ")", ":", "{", ":param", "=>", "params", "}", "if", "params", "n", "[", ":session", "]", "=", "{", ":uuid", "=>", "uuid", "}", "if", "uuid", "if", "agent", "n", "[", ":environment", "]", "=", "(", "@cgi_data", "||", "{", "}", ")", ".", "merge", "(", ":agent_class", "=>", "agent", ".", "class", ".", "name", ")", "elsif", "@cgi_data", "n", "[", ":environment", "]", "=", "@cgi_data", "||", "{", "}", "end", "Airbrake", ".", "notify", "(", "n", ",", "{", "}", ",", ":right_agent", ")", "end", "true", "rescue", "Exception", "=>", "e", "raise", "if", "e", ".", "class", ".", "name", "=~", "/", "/", "# keep us from going insane while running tests", "Log", ".", "error", "(", "\"Failed to notify Errbit\"", ",", "e", ",", ":trace", ")", "end" ]

[ "Notify", "Errbit", "of", "error", "if", "notification", "enabled" ]

[ "def", "notify_callback", "Proc", ".", "new", "do", "|", "exception", ",", "packet", ",", "agent", ",", "component", "|", "notify", "(", "exception", ",", "packet", ",", "agent", ",", "component", ")", "end", "end" ]

[ "Create", "proc", "for", "making", "callback", "to", "notifier" ]

[ "def", "notify_init", "(", "agent_name", ",", "options", ")", "if", "options", "[", ":airbrake_endpoint", "]", "&&", "options", "[", ":airbrake_api_key", "]", "unless", "require_succeeds?", "(", "\"airbrake-ruby\"", ")", "raise", "RuntimeError", ",", "\"airbrake-ruby gem missing - required if airbrake options used in ErrorTracker\"", "end", "@cgi_data", "=", "{", ":process", "=>", "$0", ",", ":pid", "=>", "Process", ".", "pid", ",", ":agent_name", "=>", "agent_name", "}", "@cgi_data", "[", ":shard_id", "]", "=", "options", "[", ":shard_id", "]", "if", "options", "[", ":shard_id", "]", "@filter_params", "=", "(", "options", "[", ":filter_params", "]", "||", "[", "]", ")", ".", "map", "{", "|", "p", "|", "p", ".", "to_s", "}", "@notify_enabled", "=", "true", "return", "true", "if", "Airbrake", ".", "send", "(", ":configured?", ",", ":right_agent", ")", "Airbrake", ".", "configure", "(", ":right_agent", ")", "do", "|", "config", "|", "config", ".", "host", "=", "options", "[", ":airbrake_endpoint", "]", "config", ".", "project_id", "=", "options", "[", ":airbrake_api_key", "]", "config", ".", "project_key", "=", "options", "[", ":airbrake_api_key", "]", "config", ".", "root_directory", "=", "AgentConfig", ".", "root_dir", "config", ".", "environment", "=", "ENV", "[", "'RAILS_ENV'", "]", "config", ".", "app_version", "=", "CURRENT_SOURCE_SHA", "if", "defined?", "(", "CURRENT_SOURCE_SHA", ")", "end", "else", "@notify_enabled", "=", "false", "end", "true", "end" ]

[ "Configure", "Airbrake", "for", "exception", "notification" ]

[ "def", "filter", "(", "params", ")", "if", "@filter_params", "filtered_params", "=", "{", "}", "params", ".", "each", "{", "|", "k", ",", "p", "|", "filtered_params", "[", "k", "]", "=", "@filter_params", ".", "include?", "(", "k", ".", "to_s", ")", "?", "FILTERED_PARAM_VALUE", ":", "p", "}", "filtered_params", "end", "end" ]

[ "Apply", "parameter", "filter" ]

[ "def", "message_received", "(", "&", "callback", ")", "if", "block_given?", "@message_received_callbacks", "<<", "callback", "else", "@message_received_callbacks", ".", "each", "{", "|", "c", "|", "c", ".", "call", "}", "if", "@check_interval", ">", "0", "now", "=", "Time", ".", "now", "if", "(", "now", "-", "@last_received", ")", ">", "MIN_RESTART_INACTIVITY_TIMER_INTERVAL", "@last_received", "=", "now", "restart_inactivity_timer", "end", "end", "end", "true", "end" ]

[ "Update", "the", "time", "this", "agent", "last", "received", "a", "request", "or", "response", "message", "and", "restart", "the", "inactivity", "timer", "thus", "deferring", "the", "next", "connectivity", "check", "Also", "forward", "this", "message", "receipt", "notification", "to", "any", "callbacks", "that", "have", "registered" ]

[ "def", "check", "(", "id", "=", "nil", ",", "max_ping_timeouts", "=", "MAX_PING_TIMEOUTS", ")", "unless", "@terminating", "||", "@ping_timer", "||", "(", "id", "&&", "!", "@sender", ".", "agent", ".", "client", ".", "connected?", "(", "id", ")", ")", "@ping_id", "=", "id", "@ping_timer", "=", "EM", "::", "Timer", ".", "new", "(", "PING_TIMEOUT", ")", "do", "if", "@ping_id", "begin", "@ping_stats", ".", "update", "(", "\"timeout\"", ")", "@ping_timer", "=", "nil", "@ping_timeouts", "[", "@ping_id", "]", "=", "(", "@ping_timeouts", "[", "@ping_id", "]", "||", "0", ")", "+", "1", "if", "@ping_timeouts", "[", "@ping_id", "]", ">=", "max_ping_timeouts", "ErrorTracker", ".", "log", "(", "self", ",", "\"Mapper ping via broker #{@ping_id} timed out after #{PING_TIMEOUT} seconds and now \"", "+", "\"reached maximum of #{max_ping_timeouts} timeout#{max_ping_timeouts > 1 ? 's' : ''}, \"", "+", "\"attempting to reconnect\"", ")", "host", ",", "port", ",", "index", ",", "priority", "=", "@sender", ".", "client", ".", "identity_parts", "(", "@ping_id", ")", "@sender", ".", "agent", ".", "connect", "(", "host", ",", "port", ",", "index", ",", "priority", ",", "force", "=", "true", ")", "else", "Log", ".", "warning", "(", "\"Mapper ping via broker #{@ping_id} timed out after #{PING_TIMEOUT} seconds\"", ")", "end", "rescue", "Exception", "=>", "e", "ErrorTracker", ".", "log", "(", "self", ",", "\"Failed to reconnect to broker #{@ping_id}\"", ",", "e", ")", "end", "else", "@ping_timer", "=", "nil", "end", "end", "handler", "=", "lambda", "do", "|", "_", "|", "begin", "if", "@ping_timer", "@ping_stats", ".", "update", "(", "\"success\"", ")", "@ping_timer", ".", "cancel", "@ping_timer", "=", "nil", "@ping_timeouts", "[", "@ping_id", "]", "=", "0", "@ping_id", "=", "nil", "end", "rescue", "Exception", "=>", "e", "ErrorTracker", ".", "log", "(", "self", ",", "\"Failed to cancel router ping\"", ",", "e", ")", "end", "end", "request", "=", "Request", ".", "new", "(", "\"/router/ping\"", ",", "nil", ",", "{", ":from", "=>", "@sender", ".", "identity", ",", ":token", "=>", "AgentIdentity", ".", "generate", "}", ")", "@sender", ".", "pending_requests", "[", "request", ".", "token", "]", "=", "PendingRequest", ".", "new", "(", "Request", ",", "Time", ".", "now", ",", "handler", ")", "ids", "=", "[", "@ping_id", "]", "if", "@ping_id", "@ping_id", "=", "@sender", ".", "send", "(", ":publish", ",", "request", ",", "ids", ")", ".", "first", "end", "true", "end" ]

[ "Check", "whether", "broker", "connection", "is", "usable", "by", "pinging", "a", "router", "via", "that", "broker", "Attempt", "to", "reconnect", "if", "ping", "does", "not", "respond", "in", "PING_TIMEOUT", "seconds", "and", "if", "have", "reached", "timeout", "limit", "Ignore", "request", "if", "already", "checking", "a", "connection" ]

[ "def", "restart_inactivity_timer", "@inactivity_timer", ".", "cancel", "if", "@inactivity_timer", "@inactivity_timer", "=", "EM", "::", "Timer", ".", "new", "(", "@check_interval", ")", "do", "begin", "check", "(", "id", "=", "nil", ",", "max_ping_timeouts", "=", "1", ")", "rescue", "Exception", "=>", "e", "ErrorTracker", ".", "log", "(", "self", ",", "\"Failed connectivity check\"", ",", "e", ")", "end", "end", "true", "end" ]

[ "Start", "timer", "that", "waits", "for", "inactive", "messaging", "period", "to", "end", "before", "checking", "connectivity" ]

[ "def", "serviced_by", "(", "token", ")", "if", "@cache", "[", "token", "]", "@cache", "[", "token", "]", "=", "Time", ".", "now", ".", "to_i", "@lru", ".", "push", "(", "@lru", ".", "delete", "(", "token", ")", ")", "@identity", "end", "end" ]

[ "Determine", "whether", "request", "has", "already", "been", "serviced" ]

[ "def", "stats", "if", "(", "s", "=", "size", ")", ">", "0", "now", "=", "Time", ".", "now", ".", "to_i", "{", "\"local total\"", "=>", "s", ",", "\"local max age\"", "=>", "RightSupport", "::", "Stats", ".", "elapsed", "(", "now", "-", "@cache", "[", "@lru", ".", "first", "]", ")", "}", "end", "end" ]

[ "Get", "local", "cache", "statistics" ]

[ "def", "control", "(", "options", ")", "# Initialize directory settings", "AgentConfig", ".", "cfg_dir", "=", "options", "[", ":cfg_dir", "]", "AgentConfig", ".", "pid_dir", "=", "options", "[", ":pid_dir", "]", "# List agents if requested", "list_configured_agents", "if", "options", "[", ":list", "]", "# Validate arguments", "action", "=", "options", ".", "delete", "(", ":action", ")", "fail", "(", "\"No action specified on the command line.\"", ",", "print_usage", "=", "true", ")", "unless", "action", "if", "action", "==", "'kill'", "&&", "(", "options", "[", ":pid_file", "]", ".", "nil?", "||", "!", "File", ".", "file?", "(", "options", "[", ":pid_file", "]", ")", ")", "fail", "(", "\"Missing or invalid pid file #{options[:pid_file]}\"", ",", "print_usage", "=", "true", ")", "end", "if", "options", "[", ":agent_name", "]", "if", "action", "==", "'start'", "cfg", "=", "configure_agent", "(", "action", ",", "options", ")", "else", "cfg", "=", "AgentConfig", ".", "load_cfg", "(", "options", "[", ":agent_name", "]", ")", "fail", "(", "\"Deployment is missing configuration file #{AgentConfig.cfg_file(options[:agent_name]).inspect}.\"", ")", "unless", "cfg", "end", "options", ".", "delete", "(", ":identity", ")", "options", "=", "cfg", ".", "merge", "(", "options", ")", "AgentConfig", ".", "root_dir", "=", "options", "[", ":root_dir", "]", "AgentConfig", ".", "pid_dir", "=", "options", "[", ":pid_dir", "]", "Log", ".", "program_name", "=", "syslog_program_name", "(", "options", ")", "Log", ".", "facility", "=", "syslog_facility", "(", "options", ")", "Log", ".", "log_to_file_only", "(", "options", "[", ":log_to_file_only", "]", ")", "configure_proxy", "(", "options", "[", ":http_proxy", "]", ",", "options", "[", ":http_no_proxy", "]", ")", "if", "options", "[", ":http_proxy", "]", "elsif", "options", "[", ":identity", "]", "options", "[", ":agent_name", "]", "=", "AgentConfig", ".", "agent_name", "(", "options", "[", ":identity", "]", ")", "end", "@options", "=", "DEFAULT_OPTIONS", ".", "clone", ".", "merge", "(", "options", ".", "merge", "(", "FORCED_OPTIONS", ")", ")", "FileUtils", ".", "mkdir_p", "(", "@options", "[", ":pid_dir", "]", ")", "unless", "@options", "[", ":pid_dir", "]", ".", "nil?", "||", "File", ".", "directory?", "(", "@options", "[", ":pid_dir", "]", ")", "# Execute request", "success", "=", "case", "action", "when", "/", "/", "action", "=", "'stop'", "if", "action", "==", "'killall'", "s", "=", "true", "AgentConfig", ".", "cfg_agents", ".", "each", "{", "|", "agent_name", "|", "s", "&&=", "dispatch", "(", "action", ",", "agent_name", ")", "}", "s", "when", "'kill'", "kill_process", "else", "dispatch", "(", "action", ",", "@options", "[", ":agent_name", "]", ")", "end", "exit", "(", "1", ")", "unless", "success", "end" ]

[ "Parse", "arguments", "and", "execute", "request" ]

[ "def", "kill_process", "(", "sig", "=", "'TERM'", ")", "content", "=", "IO", ".", "read", "(", "@options", "[", ":pid_file", "]", ")", "pid", "=", "content", ".", "to_i", "fail", "(", "\"Invalid pid file content #{content.inspect}\"", ")", "if", "pid", "==", "0", "begin", "Process", ".", "kill", "(", "sig", ",", "pid", ")", "rescue", "Errno", "::", "ESRCH", "=>", "e", "fail", "(", "\"Could not find process with pid #{pid}\"", ")", "rescue", "Errno", "::", "EPERM", "=>", "e", "fail", "(", "\"You don't have permissions to stop process #{pid}\"", ")", "rescue", "Exception", "=>", "e", "fail", "(", "e", ".", "message", ")", "end", "true", "end" ]

[ "Kill", "process", "defined", "in", "pid", "file" ]

[ "def", "stop_agent", "(", "agent_name", ")", "res", "=", "false", "if", "(", "pid_file", "=", "AgentConfig", ".", "pid_file", "(", "agent_name", ")", ")", "name", "=", "human_readable_name", "(", "agent_name", ",", "pid_file", ".", "identity", ")", "if", "(", "pid", "=", "pid_file", ".", "read_pid", "[", ":pid", "]", ")", "begin", "Process", ".", "kill", "(", "'TERM'", ",", "pid", ")", "res", "=", "true", "puts", "\"#{name} stopped\"", "rescue", "Errno", "::", "ESRCH", "puts", "\"#{name} not running\"", "end", "elsif", "File", ".", "file?", "(", "pid_file", ".", "to_s", ")", "puts", "\"Invalid pid file '#{pid_file.to_s}' content: #{IO.read(pid_file.to_s)}\"", "else", "puts", "\"#{name} not running\"", "end", "else", "puts", "\"Non-existent pid file for #{agent_name}\"", "end", "res", "end" ]

[ "Stop", "agent", "process" ]

[ "def", "list_configured_agents", "agents", "=", "AgentConfig", ".", "cfg_agents", "if", "agents", ".", "empty?", "puts", "\"Found no configured agents\"", "else", "puts", "\"Configured agents:\"", "agents", ".", "each", "{", "|", "a", "|", "puts", "\" - #{a}\"", "}", "end", "exit", "end" ]

[ "List", "all", "configured", "agents" ]

[ "def", "configure_agent", "(", "action", ",", "options", ")", "agent_type", "=", "options", "[", ":agent_type", "]", "agent_name", "=", "options", "[", ":agent_name", "]", "if", "agent_name", "!=", "agent_type", "&&", "(", "cfg", "=", "AgentConfig", ".", "load_cfg", "(", "agent_type", ")", ")", "base_id", "=", "(", "options", "[", ":base_id", "]", "||", "AgentIdentity", ".", "parse", "(", "cfg", "[", ":identity", "]", ")", ".", "base_id", ".", "to_s", ")", ".", "to_i", "unless", "(", "identity", "=", "AgentConfig", ".", "agent_options", "(", "agent_name", ")", "[", ":identity", "]", ")", "&&", "AgentIdentity", ".", "parse", "(", "identity", ")", ".", "base_id", "==", "base_id", "identity", "=", "AgentIdentity", ".", "new", "(", "options", "[", ":prefix", "]", "||", "'rs'", ",", "options", "[", ":agent_type", "]", ",", "base_id", ",", "options", "[", ":token", "]", ")", ".", "to_s", "end", "cfg", ".", "merge!", "(", ":identity", "=>", "identity", ")", "cfg_file", "=", "AgentConfig", ".", "store_cfg", "(", "agent_name", ",", "cfg", ")", "puts", "\"Generated configuration file for #{agent_name} agent: #{cfg_file}\"", "elsif", "!", "(", "cfg", "=", "AgentConfig", ".", "load_cfg", "(", "agent_name", ")", ")", "fail", "(", "\"Deployment is missing configuration file #{AgentConfig.cfg_file(agent_name).inspect}\"", ")", "end", "cfg", "end" ]

[ "Determine", "configuration", "settings", "for", "this", "agent", "and", "persist", "them", "if", "needed", "Reuse", "existing", "agent", "identity", "when", "possible" ]

[ "def", "configure_proxy", "(", "proxy_setting", ",", "exceptions", ")", "ENV", "[", "'HTTP_PROXY'", "]", "=", "proxy_setting", "ENV", "[", "'http_proxy'", "]", "=", "proxy_setting", "ENV", "[", "'HTTPS_PROXY'", "]", "=", "proxy_setting", "ENV", "[", "'https_proxy'", "]", "=", "proxy_setting", "ENV", "[", "'NO_PROXY'", "]", "=", "exceptions", "ENV", "[", "'no_proxy'", "]", "=", "exceptions", "true", "end" ]

[ "Enable", "the", "use", "of", "an", "HTTP", "proxy", "for", "this", "process", "and", "its", "subprocesses" ]

[ "def", "cascade_serializers", "(", "action", ",", "packet", ",", "serializers", ",", "id", "=", "nil", ")", "errors", "=", "[", "]", "serializers", ".", "map", "do", "|", "serializer", "|", "obj", "=", "nil", "begin", "obj", "=", "serializer", "==", "SecureSerializer", "?", "serializer", ".", "send", "(", "action", ",", "packet", ",", "id", ")", ":", "serializer", ".", "send", "(", "action", ",", "packet", ")", "rescue", "RightSupport", "::", "Net", "::", "NoResult", ",", "SocketError", "=>", "e", "raise", "Exceptions", "::", "ConnectivityFailure", ".", "new", "(", "\"Failed to #{action} with #{serializer.name} due to external \"", "+", "\"service access failures (#{e.class.name}: #{e.message})\"", ",", "e", ")", "rescue", "SecureSerializer", "::", "MissingCertificate", ",", "SecureSerializer", "::", "MissingPrivateKey", ",", "SecureSerializer", "::", "InvalidSignature", "=>", "e", "errors", "<<", "Log", ".", "format", "(", "\"Failed to #{action} with #{serializer.name}\"", ",", "e", ")", "rescue", "StandardError", "=>", "e", "errors", "<<", "Log", ".", "format", "(", "\"Failed to #{action} with #{serializer.name}\"", ",", "e", ",", ":trace", ")", "end", "return", "obj", "if", "obj", "end", "raise", "SerializationError", ".", "new", "(", "action", ",", "packet", ",", "serializers", ",", "errors", ".", "join", "(", "\"\\n\"", ")", ")", "end" ]

[ "Apply", "serializers", "in", "order", "until", "one", "succeeds" ]

[ "def", "method_missing", "(", "m", ",", "*", "args", ")", "res", "=", "@targets", ".", "inject", "(", "[", "]", ")", "{", "|", "res", ",", "t", "|", "res", "<<", "t", ".", "send", "(", "m", ",", "args", ")", "}", "res", "[", "0", "]", "end" ]

[ "Forward", "any", "method", "invocation", "to", "targets" ]

[ "def", "respond_to?", "(", "m", ",", "*", "args", ")", "super", "(", "m", ",", "args", ")", "||", "@targets", ".", "all?", "{", "|", "t", "|", "t", ".", "respond_to?", "(", "m", ",", "args", ")", "}", "end" ]

[ "Determine", "whether", "this", "object", "or", "ALL", "of", "its", "targets", "responds", "to", "the", "named", "method", "." ]

[ "def", "status", "(", "reason", "=", "false", ")", "case", "@status_code", "when", "SUCCESS", "then", "'success'", "when", "ERROR", "then", "'error'", "+", "(", "reason", "?", "\" (#{truncated_error})\"", ":", "\"\"", ")", "when", "CONTINUE", "then", "'continue'", "when", "RETRY", "then", "'retry'", "+", "(", "reason", "?", "\" (#{@content})\"", ":", "\"\"", ")", "when", "NON_DELIVERY", "then", "'non-delivery'", "+", "(", "reason", "?", "\" (#{@content})\"", ":", "\"\"", ")", "when", "MULTICAST", "then", "'multicast'", "when", "CANCEL", "then", "'cancel'", "+", "(", "reason", "?", "\" (#{@content})\"", ":", "\"\"", ")", "end", "end" ]

[ "User", "friendly", "result", "status" ]

[ "def", "truncated_error", "e", "=", "@content", ".", "is_a?", "(", "String", ")", "?", "@content", ":", "@content", ".", "inspect", "e", "=", "e", "[", "0", ",", "MAX_ERROR_SIZE", "-", "3", "]", "+", "\"...\"", "if", "e", ".", "size", ">", "(", "MAX_ERROR_SIZE", "-", "3", ")", "e", "end" ]

[ "Limited", "length", "error", "string" ]

[ "def", "listen", "(", "socket_port", ",", "&", "block", ")", "raise", "ArgumentError", ",", "'Missing listener block'", "unless", "block_given?", "raise", "Exceptions", "::", "Application", ",", "'Already listening'", "if", "listening", "begin", "@conn", "=", "EM", ".", "start_server", "(", "'127.0.0.1'", ",", "socket_port", ",", "ServerInputHandler", ",", "block", ")", "rescue", "Exception", "=>", "e", "raise", "Exceptions", "::", "IO", ",", "'Listen port unavailable'", "if", "e", ".", "message", "=~", "/", "/", "end", "true", "end" ]

[ "Open", "command", "socket", "and", "wait", "for", "input", "on", "it", "This", "can", "only", "be", "called", "again", "after", "stop_listening", "was", "called" ]

[ "def", "reply", "(", "conn", ",", "data", ",", "close_after_writing", "=", "true", ")", "conn", ".", "send_data", "(", "CommandSerializer", ".", "dump", "(", "data", ")", ")", "conn", ".", "close_connection_after_writing", "if", "close_after_writing", "true", "end" ]

[ "Write", "given", "data", "to", "socket", "must", "be", "listening" ]

[ "def", "manage", "(", "options", ")", "# Initialize configuration directory setting", "AgentConfig", ".", "cfg_dir", "=", "options", "[", ":cfg_dir", "]", "# Determine command", "level", "=", "options", "[", ":level", "]", "command", "=", "{", ":name", "=>", "(", "level", "?", "'set_log_level'", ":", "'get_log_level'", ")", "}", "command", "[", ":level", "]", "=", "level", ".", "to_sym", "if", "level", "# Determine candidate agents", "agent_names", "=", "if", "options", "[", ":agent_name", "]", "[", "options", "[", ":agent_name", "]", "]", "else", "AgentConfig", ".", "cfg_agents", "end", "fail", "(", "\"No agents configured\"", ")", "if", "agent_names", ".", "empty?", "# Perform command for each agent", "count", "=", "0", "agent_names", ".", "each", "do", "|", "agent_name", "|", "count", "+=", "1", "if", "request_log_level", "(", "agent_name", ",", "command", ",", "options", ")", "end", "puts", "(", "\"No agents running\"", ")", "if", "count", "==", "0", "true", "end" ]

[ "Handle", "log", "level", "request" ]

[ "def", "request_log_level", "(", "agent_name", ",", "command", ",", "options", ")", "res", "=", "false", "config_options", "=", "AgentConfig", ".", "agent_options", "(", "agent_name", ")", "unless", "config_options", ".", "empty?", "||", "(", "listen_port", "=", "config_options", "[", ":listen_port", "]", ")", ".", "nil?", "fail", "(", "\"Could not retrieve #{agent_name} agent listen port\"", ")", "unless", "listen_port", "client", "=", "CommandClient", ".", "new", "(", "listen_port", ",", "config_options", "[", ":cookie", "]", ")", "begin", "client", ".", "send_command", "(", "command", ",", "options", "[", ":verbose", "]", ",", "timeout", "=", "5", ")", "do", "|", "level", "|", "puts", "\"Agent #{agent_name} log level: #{level.to_s.upcase}\"", "end", "res", "=", "true", "rescue", "Exception", "=>", "e", "puts", "\"Command #{command.inspect} to #{agent_name} agent failed (#{e})\"", "end", "end", "res", "end" ]

[ "Send", "log", "level", "request", "to", "agent" ]

[ "def", "parse_common", "(", "opts", ",", "options", ")", "opts", ".", "on", "(", "\"--test\"", ")", "do", "options", "[", ":user", "]", "=", "'test'", "options", "[", ":pass", "]", "=", "'testing'", "options", "[", ":vhost", "]", "=", "'/right_net'", "options", "[", ":test", "]", "=", "true", "options", "[", ":pid_dir", "]", "=", "Dir", ".", "tmpdir", "options", "[", ":base_id", "]", "=", "\"#{rand(1000000)}\"", "options", "[", ":options", "]", "[", ":log_dir", "]", "=", "Dir", ".", "tmpdir", "end", "opts", ".", "on", "(", "\"-i\"", ",", "\"--identity ID\"", ")", "do", "|", "id", "|", "options", "[", ":base_id", "]", "=", "id", "end", "opts", ".", "on", "(", "\"-t\"", ",", "\"--token TOKEN\"", ")", "do", "|", "t", "|", "options", "[", ":token", "]", "=", "t", "end", "opts", ".", "on", "(", "\"-S\"", ",", "\"--secure-identity\"", ")", "do", "options", "[", ":secure_identity", "]", "=", "true", "end", "opts", ".", "on", "(", "\"-x\"", ",", "\"--prefix PREFIX\"", ")", "do", "|", "p", "|", "options", "[", ":prefix", "]", "=", "p", "end", "opts", ".", "on", "(", "\"--url URL\"", ")", "do", "|", "url", "|", "uri", "=", "URI", ".", "parse", "(", "url", ")", "options", "[", ":user", "]", "=", "uri", ".", "user", "if", "uri", ".", "user", "options", "[", ":pass", "]", "=", "uri", ".", "password", "if", "uri", ".", "password", "options", "[", ":host", "]", "=", "uri", ".", "host", "options", "[", ":port", "]", "=", "uri", ".", "port", "if", "uri", ".", "port", "options", "[", ":vhost", "]", "=", "uri", ".", "path", "if", "(", "uri", ".", "path", "&&", "!", "uri", ".", "path", ".", "empty?", ")", "end", "opts", ".", "on", "(", "\"-u\"", ",", "\"--user USER\"", ")", "do", "|", "user", "|", "options", "[", ":user", "]", "=", "user", "end", "opts", ".", "on", "(", "\"-p\"", ",", "\"--pass PASSWORD\"", ")", "do", "|", "pass", "|", "options", "[", ":pass", "]", "=", "pass", "end", "opts", ".", "on", "(", "\"-v\"", ",", "\"--vhost VHOST\"", ")", "do", "|", "vhost", "|", "options", "[", ":vhost", "]", "=", "vhost", "end", "opts", ".", "on", "(", "\"-P\"", ",", "\"--port PORT\"", ")", "do", "|", "port", "|", "options", "[", ":port", "]", "=", "port", "end", "opts", ".", "on", "(", "\"-h\"", ",", "\"--host HOST\"", ")", "do", "|", "host", "|", "options", "[", ":host", "]", "=", "host", "end", "opts", ".", "on", "(", "'--type TYPE'", ")", "do", "|", "t", "|", "options", "[", ":agent_type", "]", "=", "t", "end", "opts", ".", "on_tail", "(", "\"--help\"", ")", "do", "puts", "Usage", ".", "scan", "(", "__FILE__", ")", "exit", "end", "opts", ".", "on_tail", "(", "\"--version\"", ")", "do", "puts", "version", "exit", "end", "true", "end" ]

[ "Parse", "common", "options", "between", "rad", "and", "rnac" ]

[ "def", "resolve_identity", "(", "options", ")", "options", "[", ":agent_type", "]", "=", "agent_type", "(", "options", "[", ":agent_type", "]", ",", "options", "[", ":agent_name", "]", ")", "if", "options", "[", ":base_id", "]", "base_id", "=", "options", "[", ":base_id", "]", ".", "to_i", "if", "base_id", ".", "abs", ".", "to_s", "!=", "options", "[", ":base_id", "]", "puts", "\"** Identity needs to be a positive integer\"", "exit", "(", "1", ")", "end", "token", "=", "if", "options", "[", ":secure_identity", "]", "RightScale", "::", "SecureIdentity", ".", "derive", "(", "base_id", ",", "options", "[", ":token", "]", ")", "else", "options", "[", ":token", "]", "end", "options", "[", ":identity", "]", "=", "AgentIdentity", ".", "new", "(", "options", "[", ":prefix", "]", "||", "'rs'", ",", "options", "[", ":agent_type", "]", ",", "base_id", ",", "token", ")", ".", "to_s", "end", "end" ]

[ "Generate", "agent", "identity", "from", "options", "Build", "identity", "from", "base_id", "token", "prefix", "and", "agent", "name" ]

[ "def", "agent_type", "(", "type", ",", "name", ")", "unless", "type", "if", "name", "=~", "/", "/", "type", "=", "Regexp", ".", "last_match", "(", "1", ")", "else", "type", "=", "name", "||", "\"instance\"", "end", "end", "type", "end" ]

[ "Determine", "agent", "type" ]

[ "def", "register", "(", "actor", ",", "prefix", ")", "raise", "ArgumentError", ",", "\"#{actor.inspect} is not a RightScale::Actor subclass instance\"", "unless", "RightScale", "::", "Actor", "===", "actor", "log_msg", "=", "\"[actor] #{actor.class.to_s}\"", "log_msg", "+=", "\", prefix #{prefix}\"", "if", "prefix", "&&", "!", "prefix", ".", "empty?", "Log", ".", "info", "(", "log_msg", ")", "prefix", "||=", "actor", ".", "class", ".", "default_prefix", "@actors", "[", "prefix", ".", "to_s", "]", "=", "actor", "end" ]

[ "Initialize", "registry", "Register", "as", "an", "actor" ]

[ "def", "put", "(", "key", ",", "item", ")", "if", "@items", ".", "include?", "(", "key", ")", "delete", "(", "key", ")", "end", "if", "@list", ".", "size", "==", "@max_count", "delete", "(", "@list", ".", "first", ")", "end", "@items", "[", "key", "]", "=", "item", "@list", ".", "push", "(", "key", ")", "item", "end" ]

[ "Initialize", "cache", "Add", "item", "to", "cache" ]

[ "def", "get", "(", "key", ")", "if", "@items", ".", "include?", "(", "key", ")", "@list", ".", "each_index", "do", "|", "i", "|", "if", "@list", "[", "i", "]", "==", "key", "@list", ".", "delete_at", "(", "i", ")", "break", "end", "end", "@list", ".", "push", "(", "key", ")", "@items", "[", "key", "]", "else", "return", "nil", "unless", "block_given?", "self", "[", "key", "]", "=", "yield", "end", "end" ]

[ "Retrieve", "item", "from", "cache", "Store", "item", "returned", "by", "given", "block", "if", "any" ]

[ "def", "delete", "(", "key", ")", "c", "=", "@items", "[", "key", "]", "if", "c", "@items", ".", "delete", "(", "key", ")", "@list", ".", "each_index", "do", "|", "i", "|", "if", "@list", "[", "i", "]", "==", "key", "@list", ".", "delete_at", "(", "i", ")", "break", "end", "end", "c", "end", "end" ]

[ "Delete", "item", "from", "cache" ]

[ "def", "check_health", "(", "host", "=", "nil", ")", "begin", "@http_client", ".", "health_check_proc", ".", "call", "(", "host", "||", "@urls", ".", "first", ")", "rescue", "StandardError", "=>", "e", "if", "e", ".", "respond_to?", "(", ":http_code", ")", "&&", "RETRY_STATUS_CODES", ".", "include?", "(", "e", ".", "http_code", ")", "raise", "NotResponding", ".", "new", "(", "\"#{@server_name || host} not responding\"", ",", "e", ")", "else", "raise", "end", "end", "end" ]

[ "Create", "client", "for", "making", "HTTP", "REST", "requests" ]

[ "def", "request_headers", "(", "request_uuid", ",", "options", ")", "headers", "=", "{", "\"X-Request-Lineage-Uuid\"", "=>", "request_uuid", ",", ":accept", "=>", "\"application/json\"", "}", "headers", "[", "\"X-API-Version\"", "]", "=", "@api_version", "if", "@api_version", "headers", ".", "merge!", "(", "options", "[", ":headers", "]", ")", "if", "options", "[", ":headers", "]", "headers", "[", "\"X-DEBUG\"", "]", "=", "true", "if", "Log", ".", "level", "==", ":debug", "headers", "end" ]

[ "Construct", "headers", "for", "request" ]

[ "def", "rest_request", "(", "verb", ",", "path", ",", "connect_options", ",", "request_options", ",", "used", ")", "result", ",", "code", ",", "body", ",", "headers", "=", "@balancer", ".", "request", "do", "|", "host", "|", "uri", "=", "URI", ".", "parse", "(", "host", ")", "uri", ".", "user", "=", "uri", ".", "password", "=", "nil", "used", "[", ":host", "]", "=", "uri", ".", "to_s", "@http_client", ".", "request", "(", "verb", ",", "path", ",", "host", ",", "connect_options", ",", "request_options", ")", "end", "[", "result", ",", "code", ",", "body", ",", "headers", "]", "end" ]

[ "Make", "REST", "request" ]

[ "def", "poll_request", "(", "path", ",", "connect_options", ",", "request_options", ",", "request_timeout", ",", "started_at", ",", "used", ")", "result", "=", "code", "=", "body", "=", "headers", "=", "nil", "if", "(", "connection", "=", "@http_client", ".", "connections", "[", "path", "]", ")", ".", "nil?", "||", "Time", ".", "now", ">=", "connection", "[", ":expires_at", "]", "# Use normal :get request using request balancer for first poll", "result", ",", "code", ",", "body", ",", "headers", "=", "rest_request", "(", ":get", ",", "path", ",", "connect_options", ",", "request_options", ".", "dup", ",", "used", ")", "return", "[", "result", ",", "code", ",", "body", ",", "headers", "]", "if", "(", "Time", ".", "now", "-", "started_at", ")", ">=", "request_timeout", "end", "if", "result", ".", "nil?", "&&", "(", "connection", "=", "@http_client", ".", "connections", "[", "path", "]", ")", "&&", "Time", ".", "now", "<", "connection", "[", ":expires_at", "]", "begin", "# Continue to poll using same connection until get result, timeout, or hit error", "used", "[", ":host", "]", "=", "connection", "[", ":host", "]", "result", ",", "code", ",", "body", ",", "headers", "=", "@http_client", ".", "poll", "(", "connection", ",", "request_options", ",", "started_at", "+", "request_timeout", ")", "rescue", "HttpException", ",", "RestClient", "::", "Exception", "=>", "e", "raise", "NotResponding", ".", "new", "(", "e", ".", "http_body", ",", "e", ")", "if", "RETRY_STATUS_CODES", ".", "include?", "(", "e", ".", "http_code", ")", "raise", "NotResponding", ".", "new", "(", "\"Request timeout\"", ",", "e", ")", "if", "e", ".", "is_a?", "(", "RestClient", "::", "RequestTimeout", ")", "raise", "end", "end", "[", "result", ",", "code", ",", "body", ",", "headers", "]", "end" ]

[ "Make", "long", "-", "polling", "request" ]

[ "def", "handle_no_result", "(", "no_result", ",", "host", ")", "server_name", "=", "@server_name", "||", "host", "e", "=", "no_result", ".", "details", ".", "values", ".", "flatten", ".", "last", "if", "no_result", ".", "details", ".", "empty?", "yield", "(", "no_result", ")", "raise", "NotResponding", ".", "new", "(", "\"#{server_name} not responding\"", ",", "no_result", ")", "elsif", "e", ".", "respond_to?", "(", ":http_code", ")", "&&", "RETRY_STATUS_CODES", ".", "include?", "(", "e", ".", "http_code", ")", "yield", "(", "e", ")", "if", "e", ".", "http_code", "==", "504", "&&", "(", "e", ".", "http_body", "&&", "!", "e", ".", "http_body", ".", "empty?", ")", "raise", "NotResponding", ".", "new", "(", "e", ".", "http_body", ",", "e", ")", "else", "raise", "NotResponding", ".", "new", "(", "\"#{server_name} not responding\"", ",", "e", ")", "end", "elsif", "e", ".", "is_a?", "(", "RestClient", "::", "RequestTimeout", ")", "# Special case RequestTimeout because http_code is typically nil given no actual response", "yield", "(", "e", ")", "raise", "NotResponding", ".", "new", "(", "\"Request timeout\"", ",", "e", ")", "else", "yield", "(", "e", ")", "raise", "e", "end", "true", "end" ]

[ "Handle", "no", "result", "from", "balancer", "Distinguish", "the", "not", "responding", "case", "since", "it", "likely", "warrants", "a", "retry", "by", "the", "client", "Also", "try", "to", "distinguish", "between", "the", "targeted", "server", "not", "responding", "and", "that", "server", "gatewaying", "to", "another", "server", "that", "is", "not", "responding", "so", "that", "the", "receiver", "of", "the", "resulting", "exception", "is", "clearer", "as", "to", "the", "source", "of", "the", "problem" ]

[ "def", "log_success", "(", "result", ",", "code", ",", "body", ",", "headers", ",", "host", ",", "path", ",", "request_uuid", ",", "started_at", ",", "log_level", ")", "length", "=", "(", "headers", "&&", "headers", "[", ":content_length", "]", ")", "||", "(", "body", "&&", "body", ".", "size", ")", "||", "\"-\"", "duration", "=", "\"%.0fms\"", "%", "(", "(", "Time", ".", "now", "-", "started_at", ")", "*", "1000", ")", "completed", "=", "\"Completed <#{request_uuid}> in #{duration} | #{code || \"nil\"} [#{host}#{path}] | #{length} bytes\"", "completed", "<<", "\" | #{result.inspect}\"", "if", "Log", ".", "level", "==", ":debug", "Log", ".", "send", "(", "log_level", ",", "completed", ")", "true", "end" ]

[ "Log", "successful", "request", "completion" ]

[ "def", "log_failure", "(", "host", ",", "path", ",", "params", ",", "filter", ",", "request_uuid", ",", "started_at", ",", "exception", ")", "code", "=", "exception", ".", "respond_to?", "(", ":http_code", ")", "?", "exception", ".", "http_code", ":", "\"nil\"", "duration", "=", "\"%.0fms\"", "%", "(", "(", "Time", ".", "now", "-", "started_at", ")", "*", "1000", ")", "ErrorTracker", ".", "log", "(", "self", ",", "\"Failed <#{request_uuid}> in #{duration} | #{code} \"", "+", "log_text", "(", "path", ",", "params", ",", "filter", ",", "host", ",", "exception", ")", ")", "true", "end" ]

[ "Log", "request", "failure", "Also", "report", "it", "as", "audit", "entry", "if", "an", "instance", "is", "targeted" ]

[ "def", "log_text", "(", "path", ",", "params", ",", "filter", ",", "host", "=", "nil", ",", "exception", "=", "nil", ")", "text", "=", "\"#{path} #{filter(params, filter).inspect}\"", "text", "=", "\"[#{host}#{text}]\"", "if", "host", "text", "<<", "\" | #{self.class.exception_text(exception)}\"", "if", "exception", "text", "end" ]

[ "Generate", "log", "text", "describing", "request", "and", "failure", "if", "any" ]

[ "def", "filter", "(", "params", ",", "filter", ")", "if", "filter", ".", "empty?", "||", "!", "params", ".", "is_a?", "(", "Hash", ")", "params", "else", "filtered_params", "=", "{", "}", "params", ".", "each", "do", "|", "k", ",", "p", "|", "s", "=", "k", ".", "to_s", "if", "filter", ".", "include?", "(", "s", ")", "filtered_params", "[", "k", "]", "=", "FILTERED_PARAM_VALUE", "else", "filtered_params", "[", "k", "]", "=", "CONTENT_FILTERED_PARAMS", ".", "include?", "(", "s", ")", "?", "filter", "(", "p", ",", "filter", ")", ":", "p", "end", "end", "filtered_params", "end", "end" ]

[ "Apply", "parameter", "hiding", "filter" ]

[ "def", "split", "(", "object", ",", "pattern", "=", "/", "\\s", "/", ")", "object", "?", "(", "object", ".", "is_a?", "(", "Array", ")", "?", "object", ":", "object", ".", "split", "(", "pattern", ")", ")", ":", "[", "]", "end" ]

[ "Split", "string", "into", "an", "array", "unless", "nil", "or", "already", "an", "array" ]

[ "def", "manage", "(", "options", ")", "init_log", "if", "options", "[", ":verbose", "]", "AgentConfig", ".", "cfg_dir", "=", "options", "[", ":cfg_dir", "]", "options", "[", ":timeout", "]", "||=", "DEFAULT_TIMEOUT", "request_stats", "(", "options", ")", "rescue", "Exception", "=>", "e", "fail", "(", "\"#{e}\\n#{e.backtrace.join(\"\\n\")}\"", ")", "unless", "e", ".", "is_a?", "(", "SystemExit", ")", "end" ]

[ "Initialize", "manager", "Handle", "stats", "request" ]

[ "def", "request_stats", "(", "options", ")", "# Determine candidate agents", "agent_names", "=", "if", "options", "[", ":agent_name", "]", "[", "options", "[", ":agent_name", "]", "]", "else", "AgentConfig", ".", "cfg_agents", "end", "fail", "(", "\"No agents configured\"", ")", "if", "agent_names", ".", "empty?", "# Request stats from agents", "count", "=", "0", "agent_names", ".", "each", "do", "|", "agent_name", "|", "begin", "count", "+=", "1", "if", "request_agent_stats", "(", "agent_name", ",", "options", ")", "rescue", "Exception", "=>", "e", "$stderr", ".", "puts", "\"Command to #{agent_name} agent failed (#{e})\"", "unless", "e", ".", "is_a?", "(", "SystemExit", ")", "end", "end", "$stderr", ".", "puts", "(", "\"No agents running\"", ")", "if", "count", "==", "0", "end" ]

[ "Request", "and", "display", "statistics", "for", "agents" ]

[ "def", "request_agent_stats", "(", "agent_name", ",", "options", ")", "res", "=", "false", "config_options", "=", "AgentConfig", ".", "agent_options", "(", "agent_name", ")", "unless", "config_options", ".", "empty?", "||", "(", "listen_port", "=", "config_options", "[", ":listen_port", "]", ")", ".", "nil?", "client", "=", "CommandClient", ".", "new", "(", "listen_port", ",", "config_options", "[", ":cookie", "]", ")", "command", "=", "{", ":name", "=>", ":stats", ",", ":reset", "=>", "options", "[", ":reset", "]", "}", "begin", "client", ".", "send_command", "(", "command", ",", "verbose", "=", "false", ",", "options", "[", ":timeout", "]", ")", "{", "|", "r", "|", "display", "(", "agent_name", ",", "r", ",", "options", ")", "}", "res", "=", "true", "rescue", "Exception", "=>", "e", "msg", "=", "\"Could not retrieve #{agent_name} agent stats: #{e}\"", "msg", "+=", "\"\\n\"", "+", "e", ".", "backtrace", ".", "join", "(", "\"\\n\"", ")", "unless", "e", ".", "message", "=~", "/", "/", "fail", "(", "msg", ")", "end", "end", "res", "end" ]

[ "Request", "and", "display", "statistics", "for", "agent" ]

[ "def", "disable", "if", "offline?", "&&", "@state", "!=", ":created", "Log", ".", "info", "(", "\"[offline] Connection to RightNet re-established\"", ")", "@offline_stats", ".", "finish", "cancel_timer", "@state", "=", ":flushing", "# Wait a bit to avoid flooding RightNet", "EM", ".", "add_timer", "(", "rand", "(", "MAX_QUEUE_FLUSH_DELAY", ")", ")", "{", "flush", "}", "end", "true", "end" ]

[ "Switch", "back", "to", "sending", "requests", "after", "in", "-", "memory", "queue", "gets", "flushed", "Idempotent" ]

[ "def", "queue_request", "(", "kind", ",", "type", ",", "payload", ",", "target", ",", "token", ",", "expires_at", ",", "skewed_by", ",", "&", "callback", ")", "request", "=", "{", ":kind", "=>", "kind", ",", ":type", "=>", "type", ",", ":payload", "=>", "payload", ",", ":target", "=>", "target", ",", ":token", "=>", "token", ",", ":expires_at", "=>", "expires_at", ",", ":skewed_by", "=>", "skewed_by", ",", ":callback", "=>", "callback", "}", "Log", ".", "info", "(", "\"[offline] Queuing request: #{request.inspect}\"", ")", "vote_to_restart", "if", "(", "@restart_vote_count", "+=", "1", ")", ">=", "MAX_QUEUED_REQUESTS", "if", "@state", "==", ":initializing", "# We are in the initialization callback, requests should be put at the head of the queue", "@queue", ".", "unshift", "(", "request", ")", "else", "@queue", "<<", "request", "end", "true", "end" ]

[ "Queue", "given", "request", "in", "memory" ]

[ "def", "flush", "(", "again", "=", "false", ")", "if", "@state", "==", ":flushing", "Log", ".", "info", "(", "\"[offline] Starting to flush request queue of size #{@queue.size}\"", ")", "unless", "again", "||", "@mode", "==", ":initializing", "if", "@queue", ".", "any?", "r", "=", "@queue", ".", "shift", "options", "=", "{", ":token", "=>", "r", "[", ":token", "]", "}", "if", "r", "[", ":expires_at", "]", "!=", "0", "&&", "(", "options", "[", ":time_to_live", "]", "=", "r", "[", ":expires_at", "]", "-", "Time", ".", "now", ".", "to_i", ")", "<=", "0", "Log", ".", "info", "(", "\"[offline] Dropping queued request <#{r[:token]}> because it expired \"", "+", "\"#{(-options[:time_to_live]).round} sec ago\"", ")", "else", "Sender", ".", "instance", ".", "send", "(", "r", "[", ":kind", "]", ",", "r", "[", ":type", "]", ",", "r", "[", ":payload", "]", ",", "r", "[", ":target", "]", ",", "options", ",", "r", "[", ":callback", "]", ")", "end", "end", "if", "@queue", ".", "empty?", "Log", ".", "info", "(", "\"[offline] Request queue flushed, resuming normal operations\"", ")", "unless", "@mode", "==", ":initializing", "@mode", "=", ":online", "@state", "=", ":running", "else", "EM", ".", "next_tick", "{", "flush", "(", "true", ")", "}", "end", "end", "true", "end" ]

[ "Send", "any", "requests", "that", "were", "queued", "while", "in", "offline", "mode", "and", "have", "not", "yet", "timed", "out", "Do", "this", "asynchronously", "to", "allow", "for", "agents", "to", "respond", "to", "requests", "Once", "all", "in", "-", "memory", "requests", "have", "been", "flushed", "switch", "off", "offline", "mode" ]

[ "def", "fingerprint", "h", "=", "Digest", "::", "SHA2", ".", "new", "h", "<<", "(", "self", ".", "exclusive", "?", "'true'", ":", "'false'", ")", "users", "=", "self", ".", "users", ".", "sort", "{", "|", "a", ",", "b", "|", "a", ".", "uuid", "<=>", "b", ".", "uuid", "}", "users", ".", "each", "do", "|", "u", "|", "h", "<<", "format", "(", "\",(%d,%s,%s,%d,%s\"", ",", "u", ".", "uuid", ",", "u", ".", "common_name", ",", "(", "u", ".", "superuser", "?", "'true'", ":", "'false'", ")", ",", "(", "u", ".", "expires_at", "?", "u", ".", "expires_at", ".", "to_i", ":", "0", ")", ",", "u", ".", "username", ")", "u", ".", "public_key_fingerprints", ".", "each", "do", "|", "fp", "|", "h", "<<", "\",\"", "<<", "fp", "end", "h", "<<", "')'", "end", "h", ".", "hexdigest", "end" ]

[ "Compute", "a", "cryptographic", "hash", "of", "the", "information", "in", "this", "policy", ";", "helps", "callers", "compare", "two", "policies", "to", "see", "if", "they", "are", "equivalent", "." ]

[ "def", "request", "(", "verb", ",", "path", ",", "host", ",", "connect_options", ",", "request_options", ")", "url", "=", "host", "+", "path", "+", "request_options", ".", "delete", "(", ":query", ")", ".", "to_s", "result", "=", "request_once", "(", "verb", ",", "url", ",", "request_options", ")", "@connections", "[", "path", "]", "=", "{", ":host", "=>", "host", ",", ":path", "=>", "path", ",", ":expires_at", "=>", "Time", ".", "now", "+", "BalancedHttpClient", "::", "CONNECTION_REUSE_TIMEOUT", "}", "result", "end" ]

[ "Make", "HTTP", "request" ]

[ "def", "poll", "(", "connection", ",", "request_options", ",", "stop_at", ")", "url", "=", "connection", "[", ":host", "]", "+", "connection", "[", ":path", "]", "+", "request_options", ".", "delete", "(", ":query", ")", ".", "to_s", "begin", "result", ",", "code", ",", "body", ",", "headers", "=", "request_once", "(", ":get", ",", "url", ",", "request_options", ")", "end", "until", "result", "||", "Time", ".", "now", ">=", "stop_at", "connection", "[", ":expires_at", "]", "=", "Time", ".", "now", "+", "BalancedHttpClient", "::", "CONNECTION_REUSE_TIMEOUT", "[", "result", ",", "code", ",", "body", ",", "headers", "]", "end" ]

[ "Make", "long", "-", "polling", "requests", "until", "receive", "data", "hit", "error", "or", "timeout" ]

[ "def", "request_once", "(", "verb", ",", "url", ",", "request_options", ")", "if", "(", "r", "=", "RightSupport", "::", "Net", "::", "HTTPClient", ".", "new", ".", "send", "(", "verb", ",", "url", ",", "request_options", ")", ")", "[", "BalancedHttpClient", ".", "response", "(", "r", ".", "code", ",", "r", ".", "body", ",", "r", ".", "headers", ",", "request_options", "[", ":headers", "]", "[", ":accept", "]", ")", ",", "r", ".", "code", ",", "r", ".", "body", ",", "r", ".", "headers", "]", "else", "[", "nil", ",", "nil", ",", "nil", ",", "nil", "]", "end", "end" ]

[ "Make", "HTTP", "request", "once" ]

[ "def", "[]=", "(", "token", ",", "pending_request", ")", "now", "=", "Time", ".", "now", "if", "(", "now", "-", "@last_cleanup", ")", ">", "MIN_CLEANUP_INTERVAL", "self", ".", "reject!", "{", "|", "t", ",", "r", "|", "r", ".", "kind", "==", ":send_push", "&&", "(", "now", "-", "r", ".", "receive_time", ")", ">", "MAX_PUSH_AGE", "}", "@last_cleanup", "=", "now", "end", "super", "end" ]

[ "Create", "cache", "Store", "pending", "request" ]

[ "def", "deploy", "(", "options", ")", "# Initialize directory settings", "AgentConfig", ".", "root_dir", "=", "options", "[", ":root_dir", "]", "AgentConfig", ".", "cfg_dir", "=", "options", "[", ":cfg_dir", "]", "AgentConfig", ".", "pid_dir", "=", "options", "[", ":pid_dir", "]", "# Configure agent", "cfg", "=", "load_init_cfg", "check_agent", "(", "options", ",", "cfg", ")", "cfg", "=", "configure", "(", "options", ",", "cfg", ")", "# Persist configuration", "persist", "(", "options", ",", "cfg", ")", "# Setup agent monitoring", "monitor", "(", "options", ")", "if", "options", "[", ":monit", "]", "true", "end" ]

[ "Generate", "configuration", "from", "specified", "options", "and", "the", "agent", "s", "base", "options", "and", "write", "them", "to", "a", "file" ]

[ "def", "load_init_cfg", "cfg", "=", "{", "}", "if", "(", "cfg_file", "=", "AgentConfig", ".", "init_cfg_file", ")", "&&", "(", "cfg_data", "=", "YAML", ".", "load", "(", "IO", ".", "read", "(", "cfg_file", ")", ")", ")", "cfg", "=", "SerializationHelper", ".", "symbolize_keys", "(", "cfg_data", ")", "rescue", "nil", "fail", "(", "\"Cannot read configuration for agent #{cfg_file.inspect}\"", ")", "unless", "cfg", "end", "cfg", "end" ]

[ "Load", "initial", "configuration", "for", "agent", "if", "any" ]

[ "def", "check_agent", "(", "options", ",", "cfg", ")", "identity", "=", "options", "[", ":identity", "]", "agent_type", "=", "options", "[", ":agent_type", "]", "type", "=", "AgentIdentity", ".", "parse", "(", "identity", ")", ".", "agent_type", "if", "identity", "fail", "(", "\"Agent type #{agent_type.inspect} and identity #{identity.inspect} are inconsistent\"", ")", "if", "agent_type", "!=", "type", "fail", "(", "\"Cannot find agent init.rb file in init directory of #{AgentConfig.root_dir.inspect}\"", ")", "unless", "AgentConfig", ".", "init_file", "actors", "=", "cfg", "[", ":actors", "]", "fail", "(", "'Agent configuration is missing actors'", ")", "unless", "actors", "&&", "actors", ".", "respond_to?", "(", ":each", ")", "actors_dirs", "=", "AgentConfig", ".", "actors_dirs", "actors", ".", "each", "do", "|", "a", "|", "found", "=", "false", "actors_dirs", ".", "each", "{", "|", "d", "|", "break", "if", "(", "found", "=", "File", ".", "exist?", "(", "File", ".", "normalize_path", "(", "File", ".", "join", "(", "d", ",", "\"#{a}.rb\"", ")", ")", ")", ")", "}", "fail", "(", "\"Cannot find source for actor #{a.inspect} in #{actors_dirs.inspect}\"", ")", "unless", "found", "end", "true", "end" ]

[ "Check", "agent", "type", "consistency", "and", "existence", "of", "initialization", "file", "and", "actors", "directory" ]

[ "def", "persist", "(", "options", ",", "cfg", ")", "overrides", "=", "options", "[", ":options", "]", "overrides", ".", "each", "{", "|", "k", ",", "v", "|", "cfg", "[", "k", "]", "=", "v", "}", "if", "overrides", "cfg_file", "=", "AgentConfig", ".", "store_cfg", "(", "options", "[", ":agent_name", "]", ",", "cfg", ")", "unless", "options", "[", ":quiet", "]", "puts", "\"Generated configuration file for #{options[:agent_name]} agent: #{cfg_file}\"", "unless", "options", "[", ":quiet", "]", "end", "true", "end" ]

[ "Write", "configuration", "options", "to", "file", "after", "applying", "any", "overrides" ]

[ "def", "add_repo", "(", "repo_sha", ",", "repo_detail", ",", "cookbook_positions", ")", "@repositories", "||=", "{", "}", "@repositories", "[", "repo_sha", "]", "=", "DevRepository", ".", "new", "(", "repo_detail", "[", ":repo_type", "]", ",", "repo_detail", "[", ":url", "]", ",", "repo_detail", "[", ":tag", "]", ",", "repo_detail", "[", ":cookboooks_path", "]", ",", "repo_detail", "[", ":ssh_key", "]", ",", "repo_detail", "[", ":username", "]", ",", "repo_detail", "[", ":password", "]", ",", "repo_sha", ",", "cookbook_positions", ")", "end" ]

[ "Add", "a", "repository", "..." ]

[ "def", "list_command", "(", "opts", ")", "usage", "=", "\"Agent exposes the following commands:\\n\"", "COMMANDS", ".", "reject", "{", "|", "k", ",", "_", "|", "k", "==", ":list", "||", "k", ".", "to_s", "=~", "/", "/", "}", ".", "each", "do", "|", "c", "|", "c", ".", "each", "{", "|", "k", ",", "v", "|", "usage", "+=", "\" - #{k.to_s}: #{v}\\n\"", "}", "end", "CommandIO", ".", "instance", ".", "reply", "(", "opts", "[", ":conn", "]", ",", "usage", ")", "end" ]

[ "List", "command", "implementation" ]

[ "def", "set_log_level_command", "(", "opts", ")", "Log", ".", "level", "=", "opts", "[", ":level", "]", "if", "[", ":debug", ",", ":info", ",", ":warn", ",", ":error", ",", ":fatal", "]", ".", "include?", "(", "opts", "[", ":level", "]", ")", "CommandIO", ".", "instance", ".", "reply", "(", "opts", "[", ":conn", "]", ",", "Log", ".", "level", ")", "end" ]

[ "Set", "log", "level", "command" ]

[ "def", "send_push", "(", "type", ",", "payload", "=", "nil", ",", "target", "=", "nil", ",", "options", "=", "{", "}", ",", "&", "callback", ")", "build_and_send_packet", "(", ":send_push", ",", "type", ",", "payload", ",", "target", ",", "options", ",", "callback", ")", "end" ]

[ "Send", "a", "request", "to", "a", "single", "target", "or", "multiple", "targets", "with", "no", "response", "expected", "other", "than", "routing", "failures", "Persist", "the", "request", "en", "route", "to", "reduce", "the", "chance", "of", "it", "being", "lost", "at", "the", "expense", "of", "some", "additional", "network", "overhead", "Enqueue", "the", "request", "if", "the", "target", "is", "not", "currently", "available", "Never", "automatically", "retry", "the", "request", "if", "there", "is", "the", "possibility", "of", "it", "being", "duplicated", "Set", "time", "-", "to", "-", "live", "to", "be", "forever" ]

[ "def", "send_request", "(", "type", ",", "payload", "=", "nil", ",", "target", "=", "nil", ",", "options", "=", "{", "}", ",", "&", "callback", ")", "raise", "ArgumentError", ",", "\"Missing block for response callback\"", "unless", "callback", "build_and_send_packet", "(", ":send_request", ",", "type", ",", "payload", ",", "target", ",", "options", ",", "callback", ")", "end" ]

[ "Send", "a", "request", "to", "a", "single", "target", "with", "a", "response", "expected", "Automatically", "retry", "the", "request", "if", "a", "response", "is", "not", "received", "in", "a", "reasonable", "amount", "of", "time", "or", "if", "there", "is", "a", "non", "-", "delivery", "response", "indicating", "the", "target", "is", "not", "currently", "available", "Timeout", "the", "request", "if", "a", "response", "is", "not", "received", "in", "time", "typically", "configured", "to", "2", "minutes", "Because", "of", "retries", "there", "is", "the", "possibility", "of", "duplicated", "requests", "and", "these", "are", "detected", "and", "discarded", "automatically", "for", "non", "-", "idempotent", "actions", "Allow", "the", "request", "to", "expire", "per", "the", "agent", "s", "configured", "time", "-", "to", "-", "live", "typically", "1", "minute", "Note", "that", "receiving", "a", "response", "does", "not", "guarantee", "that", "the", "request", "activity", "has", "actually", "completed", "since", "the", "request", "processing", "may", "involve", "other", "asynchronous", "requests" ]

[ "def", "build_and_send_packet", "(", "kind", ",", "type", ",", "payload", ",", "target", ",", "options", "=", "{", "}", ",", "&", "callback", ")", "if", "(", "packet", "=", "build_packet", "(", "kind", ",", "type", ",", "payload", ",", "target", ",", "options", ",", "callback", ")", ")", "action", "=", "type", ".", "split", "(", "'/'", ")", ".", "last", "received_at", "=", "@request_stats", ".", "update", "(", "action", ",", "packet", ".", "token", ")", "@request_kind_stats", ".", "update", "(", "(", "packet", ".", "selector", "==", ":all", "?", "\"fanout\"", ":", "kind", ".", "to_s", ")", "[", "5", "..", "-", "1", "]", ")", "send", "(", "\"#{@mode}_send\"", ",", "kind", ",", "target", ",", "packet", ",", "received_at", ",", "callback", ")", "end", "true", "end" ]

[ "Build", "and", "send", "packet" ]

[ "def", "build_packet", "(", "kind", ",", "type", ",", "payload", ",", "target", ",", "options", "=", "{", "}", ",", "&", "callback", ")", "validate_target", "(", "target", ",", "kind", "==", ":send_push", ")", "if", "kind", "==", ":send_push", "packet", "=", "Push", ".", "new", "(", "type", ",", "payload", ")", "packet", ".", "selector", "=", "target", "[", ":selector", "]", "||", ":any", "if", "target", ".", "is_a?", "(", "Hash", ")", "packet", ".", "persistent", "=", "true", "packet", ".", "confirm", "=", "true", "if", "callback", "time_to_live", "=", "options", "[", ":time_to_live", "]", "||", "0", "else", "packet", "=", "Request", ".", "new", "(", "type", ",", "payload", ")", "packet", ".", "selector", "=", ":any", "time_to_live", "=", "options", "[", ":time_to_live", "]", "||", "@options", "[", ":time_to_live", "]", "end", "packet", ".", "from", "=", "@identity", "packet", ".", "token", "=", "options", "[", ":token", "]", "||", "RightSupport", "::", "Data", "::", "UUID", ".", "generate", "packet", ".", "expires_at", "=", "Time", ".", "now", ".", "to_i", "+", "time_to_live", "if", "time_to_live", "&&", "time_to_live", ">", "0", "if", "target", ".", "is_a?", "(", "Hash", ")", "if", "(", "agent_id", "=", "target", "[", ":agent_id", "]", ")", "packet", ".", "target", "=", "agent_id", "else", "packet", ".", "tags", "=", "target", "[", ":tags", "]", "||", "[", "]", "packet", ".", "scope", "=", "target", "[", ":scope", "]", "end", "else", "packet", ".", "target", "=", "target", "end", "if", "queueing?", "@offline_handler", ".", "queue_request", "(", "kind", ",", "type", ",", "payload", ",", "target", ",", "packet", ".", "token", ",", "packet", ".", "expires_at", ",", "packet", ".", "skewed_by", ",", "callback", ")", "nil", "else", "packet", "end", "end" ]

[ "Build", "packet", "or", "queue", "it", "if", "offline" ]

[ "def", "handle_response", "(", "response", ")", "if", "response", ".", "is_a?", "(", "Result", ")", "token", "=", "response", ".", "token", "if", "(", "result", "=", "OperationResult", ".", "from_results", "(", "response", ")", ")", "if", "result", ".", "non_delivery?", "@non_delivery_stats", ".", "update", "(", "result", ".", "content", ".", "nil?", "?", "\"nil\"", ":", "result", ".", "content", ")", "elsif", "result", ".", "error?", "@result_error_stats", ".", "update", "(", "result", ".", "content", ".", "nil?", "?", "\"nil\"", ":", "result", ".", "content", ")", "end", "@result_stats", ".", "update", "(", "result", ".", "status", ")", "else", "@result_stats", ".", "update", "(", "response", ".", "results", ".", "nil?", "?", "\"nil\"", ":", "response", ".", "results", ")", "end", "if", "(", "pending_request", "=", "@pending_requests", "[", "token", "]", ")", "if", "result", "&&", "result", ".", "non_delivery?", "&&", "pending_request", ".", "kind", "==", ":send_request", "if", "result", ".", "content", "==", "OperationResult", "::", "TARGET_NOT_CONNECTED", "# Log and temporarily ignore so that timeout retry mechanism continues, but save reason for use below if timeout", "# Leave purging of associated request until final response, i.e., success response or retry timeout", "if", "(", "parent_token", "=", "pending_request", ".", "retry_parent_token", ")", "@pending_requests", "[", "parent_token", "]", ".", "non_delivery", "=", "result", ".", "content", "else", "pending_request", ".", "non_delivery", "=", "result", ".", "content", "end", "Log", ".", "info", "(", "\"Non-delivery of <#{token}> because #{result.content}\"", ")", "elsif", "result", ".", "content", "==", "OperationResult", "::", "RETRY_TIMEOUT", "&&", "pending_request", ".", "non_delivery", "# Request timed out but due to another non-delivery reason, so use that reason since more germane", "response", ".", "results", "=", "OperationResult", ".", "non_delivery", "(", "pending_request", ".", "non_delivery", ")", "deliver_response", "(", "response", ",", "pending_request", ")", "else", "deliver_response", "(", "response", ",", "pending_request", ")", "end", "else", "deliver_response", "(", "response", ",", "pending_request", ")", "end", "elsif", "result", "&&", "result", ".", "non_delivery?", "Log", ".", "info", "(", "\"Non-delivery of <#{token}> because #{result.content}\"", ")", "else", "Log", ".", "debug", "(", "\"No pending request for response #{response.to_s([])}\"", ")", "end", "end", "true", "end" ]

[ "Handle", "response", "to", "a", "request" ]

[ "def", "terminate", "if", "@offline_handler", "@offline_handler", ".", "terminate", "@connectivity_checker", ".", "terminate", "if", "@connectivity_checker", "pending", "=", "@pending_requests", ".", "kind", "(", ":send_request", ")", "[", "pending", ".", "size", ",", "PendingRequests", ".", "youngest_age", "(", "pending", ")", "]", "else", "[", "0", ",", "nil", "]", "end", "end" ]

[ "Take", "any", "actions", "necessary", "to", "quiesce", "client", "interaction", "in", "preparation", "for", "agent", "termination", "but", "allow", "message", "receipt", "to", "continue" ]

[ "def", "dump_requests", "info", "=", "[", "]", "if", "@pending_requests", "@pending_requests", ".", "kind", "(", ":send_request", ")", ".", "each", "do", "|", "token", ",", "request", "|", "info", "<<", "\"#{request.receive_time.localtime} <#{token}>\"", "end", "info", ".", "sort!", ".", "reverse!", "info", "=", "info", "[", "0", "..", "49", "]", "+", "[", "\"...\"", "]", "if", "info", ".", "size", ">", "50", "end", "info", "end" ]

[ "Create", "displayable", "dump", "of", "unfinished", "non", "-", "push", "request", "information", "Truncate", "list", "if", "there", "are", "more", "than", "50", "requests" ]

[ "def", "stats", "(", "reset", "=", "false", ")", "stats", "=", "{", "}", "if", "@agent", "offlines", "=", "@offline_stats", ".", "all", "offlines", ".", "merge!", "(", "\"duration\"", "=>", "@offline_stats", ".", "avg_duration", ")", "if", "offlines", "if", "@pending_requests", ".", "size", ">", "0", "pending", "=", "{", "}", "pending", "[", "\"pushes\"", "]", "=", "@pending_requests", ".", "kind", "(", ":send_push", ")", ".", "size", "requests", "=", "@pending_requests", ".", "kind", "(", ":send_request", ")", "if", "(", "pending", "[", "\"requests\"", "]", "=", "requests", ".", "size", ")", ">", "0", "pending", "[", "\"oldest age\"", "]", "=", "PendingRequests", ".", "oldest_age", "(", "requests", ")", "end", "end", "stats", "=", "{", "\"non-deliveries\"", "=>", "@non_delivery_stats", ".", "all", ",", "\"offlines\"", "=>", "offlines", ",", "\"pings\"", "=>", "@ping_stats", ".", "all", ",", "\"request kinds\"", "=>", "@request_kind_stats", ".", "all", ",", "\"requests\"", "=>", "@request_stats", ".", "all", ",", "\"requests pending\"", "=>", "pending", ",", "\"result errors\"", "=>", "@result_error_stats", ".", "all", ",", "\"results\"", "=>", "@result_stats", ".", "all", ",", "\"retries\"", "=>", "@retry_stats", ".", "all", ",", "\"send failures\"", "=>", "@send_failure_stats", ".", "all", "}", "reset_stats", "if", "reset", "end", "stats", "end" ]

[ "Get", "sender", "statistics" ]

[ "def", "reset_stats", "@ping_stats", "=", "RightSupport", "::", "Stats", "::", "Activity", ".", "new", "@retry_stats", "=", "RightSupport", "::", "Stats", "::", "Activity", ".", "new", "@request_stats", "=", "RightSupport", "::", "Stats", "::", "Activity", ".", "new", "@result_stats", "=", "RightSupport", "::", "Stats", "::", "Activity", ".", "new", "@result_error_stats", "=", "RightSupport", "::", "Stats", "::", "Activity", ".", "new", "@non_delivery_stats", "=", "RightSupport", "::", "Stats", "::", "Activity", ".", "new", "@offline_stats", "=", "RightSupport", "::", "Stats", "::", "Activity", ".", "new", "(", "measure_rate", "=", "false", ")", "@request_kind_stats", "=", "RightSupport", "::", "Stats", "::", "Activity", ".", "new", "(", "measure_rate", "=", "false", ")", "@send_failure_stats", "=", "RightSupport", "::", "Stats", "::", "Activity", ".", "new", "true", "end" ]

[ "Reset", "dispatch", "statistics" ]

[ "def", "http_send", "(", "kind", ",", "target", ",", "packet", ",", "received_at", ",", "&", "callback", ")", "if", "@options", "[", ":async_response", "]", "EM_S", ".", "next_tick", "do", "begin", "http_send_once", "(", "kind", ",", "target", ",", "packet", ",", "received_at", ",", "callback", ")", "rescue", "StandardError", "=>", "e", "ErrorTracker", ".", "log", "(", "self", ",", "\"Failed sending or handling response for #{packet.trace} #{packet.type}\"", ",", "e", ")", "end", "end", "else", "http_send_once", "(", "kind", ",", "target", ",", "packet", ",", "received_at", ",", "callback", ")", "end", "true", "end" ]

[ "Send", "request", "via", "HTTP", "Use", "next_tick", "for", "asynchronous", "response", "and", "to", "ensure", "that", "the", "request", "is", "sent", "using", "the", "main", "EM", "reactor", "thread" ]

[ "def", "http_send_once", "(", "kind", ",", "target", ",", "packet", ",", "received_at", ",", "&", "callback", ")", "begin", "method", "=", "packet", ".", "class", ".", "name", ".", "split", "(", "\"::\"", ")", ".", "last", ".", "downcase", "options", "=", "{", ":request_uuid", "=>", "packet", ".", "token", "}", "options", "[", ":time_to_live", "]", "=", "(", "packet", ".", "expires_at", "-", "Time", ".", "now", ".", "to_i", ")", "if", "packet", ".", "expires_at", ">", "0", "result", "=", "success_result", "(", "@agent", ".", "client", ".", "send", "(", "method", ",", "packet", ".", "type", ",", "packet", ".", "payload", ",", "target", ",", "options", ")", ")", "rescue", "Exceptions", "::", "Unauthorized", "=>", "e", "result", "=", "error_result", "(", "e", ".", "message", ")", "rescue", "Exceptions", "::", "ConnectivityFailure", "=>", "e", "if", "queueing?", "@offline_handler", ".", "queue_request", "(", "kind", ",", "packet", ".", "type", ",", "packet", ".", "payload", ",", "target", ",", "packet", ".", "token", ",", "packet", ".", "expires_at", ",", "packet", ".", "skewed_by", ",", "callback", ")", "result", "=", "nil", "else", "result", "=", "retry_result", "(", "e", ".", "message", ")", "end", "rescue", "Exceptions", "::", "RetryableError", "=>", "e", "result", "=", "retry_result", "(", "e", ".", "message", ")", "rescue", "Exceptions", "::", "InternalServerError", "=>", "e", "result", "=", "error_result", "(", "\"#{e.server} internal error\"", ")", "rescue", "Exceptions", "::", "Terminating", "=>", "e", "result", "=", "nil", "rescue", "StandardError", "=>", "e", "# These errors are either unexpected errors or HttpExceptions with an http_body", "# giving details about the error that are conveyed in the error_result", "if", "e", ".", "respond_to?", "(", ":http_body", ")", "# No need to log here since any HTTP request errors have already been logged", "result", "=", "error_result", "(", "e", ".", "inspect", ")", "else", "agent_type", "=", "AgentIdentity", ".", "parse", "(", "@identity", ")", ".", "agent_type", "ErrorTracker", ".", "log", "(", "self", ",", "\"Failed to send #{packet.trace} #{packet.type}\"", ",", "e", ")", "result", "=", "error_result", "(", "\"#{agent_type.capitalize} agent internal error\"", ")", "end", "end", "if", "result", "&&", "packet", ".", "is_a?", "(", "Request", ")", "result", "=", "Result", ".", "new", "(", "packet", ".", "token", ",", "@identity", ",", "result", ",", "from", "=", "packet", ".", "target", ")", "result", ".", "received_at", "=", "received_at", ".", "to_f", "@pending_requests", "[", "packet", ".", "token", "]", "=", "PendingRequest", ".", "new", "(", "kind", ",", "received_at", ",", "callback", ")", "if", "callback", "handle_response", "(", "result", ")", "end", "true", "end" ]

[ "Send", "request", "via", "HTTP", "and", "then", "immediately", "handle", "response" ]

[ "def", "amqp_send", "(", "kind", ",", "target", ",", "packet", ",", "received_at", ",", "&", "callback", ")", "begin", "@pending_requests", "[", "packet", ".", "token", "]", "=", "PendingRequest", ".", "new", "(", "kind", ",", "received_at", ",", "callback", ")", "if", "callback", "if", "packet", ".", "class", "==", "Request", "amqp_send_retry", "(", "packet", ",", "packet", ".", "token", ")", "else", "amqp_send_once", "(", "packet", ")", "end", "rescue", "TemporarilyOffline", "=>", "e", "if", "queueing?", "# Queue request until come back online", "@offline_handler", ".", "queue_request", "(", "kind", ",", "packet", ".", "type", ",", "packet", ".", "payload", ",", "target", ",", "packet", ".", "token", ",", "packet", ".", "expires_at", ",", "packet", ".", "skewed_by", ",", "callback", ")", "@pending_requests", ".", "delete", "(", "packet", ".", "token", ")", "if", "callback", "else", "# Send retry response so that requester, e.g., RetryableRequest, can retry", "result", "=", "OperationResult", ".", "retry", "(", "\"lost RightNet connectivity\"", ")", "handle_response", "(", "Result", ".", "new", "(", "packet", ".", "token", ",", "@identity", ",", "result", ",", "@identity", ")", ")", "end", "rescue", "SendFailure", "=>", "e", "# Send non-delivery response so that requester, e.g., RetryableRequest, can retry", "result", "=", "OperationResult", ".", "non_delivery", "(", "\"send failed unexpectedly\"", ")", "handle_response", "(", "Result", ".", "new", "(", "packet", ".", "token", ",", "@identity", ",", "result", ",", "@identity", ")", ")", "end", "true", "end" ]

[ "Send", "request", "via", "AMQP", "If", "lack", "connectivity", "and", "queueing", "enabled", "queue", "request" ]

[ "def", "amqp_send_once", "(", "packet", ",", "ids", "=", "nil", ")", "exchange", "=", "{", ":type", "=>", ":fanout", ",", ":name", "=>", "@request_queue", ",", ":options", "=>", "{", ":durable", "=>", "true", ",", ":no_declare", "=>", "@secure", "}", "}", "@agent", ".", "client", ".", "publish", "(", "exchange", ",", "packet", ",", ":persistent", "=>", "packet", ".", "persistent", ",", ":mandatory", "=>", "true", ",", ":log_filter", "=>", "[", ":tags", ",", ":target", ",", ":tries", ",", ":persistent", "]", ",", ":brokers", "=>", "ids", ")", "rescue", "RightAMQP", "::", "HABrokerClient", "::", "NoConnectedBrokers", "=>", "e", "ErrorTracker", ".", "log", "(", "self", ",", "error", "=", "\"Failed to publish request #{packet.trace} #{packet.type}\"", ",", "e", ",", "packet", ")", "@send_failure_stats", ".", "update", "(", "\"NoConnectedBrokers\"", ")", "raise", "TemporarilyOffline", ".", "new", "(", "error", "+", "\" (#{e.class}: #{e.message})\"", ")", "rescue", "StandardError", "=>", "e", "ErrorTracker", ".", "log", "(", "self", ",", "error", "=", "\"Failed to publish request #{packet.trace} #{packet.type}\"", ",", "e", ",", "packet", ")", "@send_failure_stats", ".", "update", "(", "e", ".", "class", ".", "name", ")", "raise", "SendFailure", ".", "new", "(", "error", "+", "\" (#{e.class}: #{e.message})\"", ")", "end" ]

[ "Send", "request", "via", "AMQP", "without", "retrying", "Use", "mandatory", "flag", "to", "request", "return", "of", "message", "if", "it", "cannot", "be", "delivered" ]

[ "def", "amqp_send_retry", "(", "packet", ",", "parent_token", ",", "count", "=", "0", ",", "multiplier", "=", "1", ",", "elapsed", "=", "0", ",", "broker_ids", "=", "nil", ")", "check_broker_ids", "=", "amqp_send_once", "(", "packet", ",", "broker_ids", ")", "if", "@retry_interval", "&&", "@retry_timeout", "&&", "parent_token", "interval", "=", "[", "(", "@retry_interval", "*", "multiplier", ")", "+", "(", "@request_stats", ".", "avg_duration", "||", "0", ")", ",", "@retry_timeout", "-", "elapsed", "]", ".", "min", "EM", ".", "add_timer", "(", "interval", ")", "do", "begin", "if", "@pending_requests", "[", "parent_token", "]", "count", "+=", "1", "elapsed", "+=", "interval", "if", "elapsed", "<", "@retry_timeout", "&&", "(", "packet", ".", "expires_at", "<=", "0", "||", "Time", ".", "now", ".", "to_i", "<", "packet", ".", "expires_at", ")", "packet", ".", "tries", "<<", "packet", ".", "token", "packet", ".", "token", "=", "RightSupport", "::", "Data", "::", "UUID", ".", "generate", "@pending_requests", "[", "parent_token", "]", ".", "retry_parent_token", "=", "parent_token", "if", "count", "==", "1", "@pending_requests", "[", "packet", ".", "token", "]", "=", "@pending_requests", "[", "parent_token", "]", "broker_ids", "||=", "@agent", ".", "client", ".", "all", "amqp_send_retry", "(", "packet", ",", "parent_token", ",", "count", ",", "multiplier", "*", "RETRY_BACKOFF_FACTOR", ",", "elapsed", ",", "broker_ids", ".", "push", "(", "broker_ids", ".", "shift", ")", ")", "@retry_stats", ".", "update", "(", "packet", ".", "type", ".", "split", "(", "'/'", ")", ".", "last", ")", "else", "Log", ".", "warning", "(", "\"RE-SEND TIMEOUT after #{elapsed.to_i} seconds for #{packet.trace} #{packet.type}\"", ")", "result", "=", "OperationResult", ".", "non_delivery", "(", "OperationResult", "::", "RETRY_TIMEOUT", ")", "handle_response", "(", "Result", ".", "new", "(", "packet", ".", "token", ",", "@identity", ",", "result", ",", "@identity", ")", ")", "end", "@connectivity_checker", ".", "check", "(", "check_broker_ids", ".", "first", ")", "if", "check_broker_ids", ".", "any?", "&&", "count", "==", "1", "end", "rescue", "TemporarilyOffline", "=>", "e", "ErrorTracker", ".", "log", "(", "self", ",", "\"Failed retry for #{packet.trace} #{packet.type} because temporarily offline\"", ")", "rescue", "SendFailure", "=>", "e", "ErrorTracker", ".", "log", "(", "self", ",", "\"Failed retry for #{packet.trace} #{packet.type} because of send failure\"", ")", "rescue", "Exception", "=>", "e", "# Not sending a response here because something more basic is broken in the retry", "# mechanism and don't want an error response to preempt a delayed actual response", "ErrorTracker", ".", "log", "(", "self", ",", "\"Failed retry for #{packet.trace} #{packet.type} without responding\"", ",", "e", ",", "packet", ")", "end", "end", "end", "true", "end" ]

[ "Send", "request", "via", "AMQP", "with", "one", "or", "more", "retries", "if", "do", "not", "receive", "a", "response", "in", "time", "Send", "timeout", "result", "if", "reach", "configured", "retry", "timeout", "limit", "Use", "exponential", "backoff", "with", "RETRY_BACKOFF_FACTOR", "for", "retry", "spacing", "Adjust", "retry", "interval", "by", "average", "response", "time", "to", "avoid", "adding", "to", "system", "load", "when", "system", "gets", "slow", "Rotate", "through", "brokers", "on", "retries", "Check", "connectivity", "after", "first", "retry", "timeout" ]

[ "def", "deliver_response", "(", "response", ",", "pending_request", ")", "@request_stats", ".", "finish", "(", "pending_request", ".", "receive_time", ",", "response", ".", "token", ")", "@pending_requests", ".", "delete", "(", "response", ".", "token", ")", "if", "pending_request", ".", "kind", "==", ":send_request", "if", "(", "parent_token", "=", "pending_request", ".", "retry_parent_token", ")", "@pending_requests", ".", "reject!", "{", "|", "k", ",", "v", "|", "k", "==", "parent_token", "||", "v", ".", "retry_parent_token", "==", "parent_token", "}", "end", "pending_request", ".", "response_handler", ".", "call", "(", "response", ")", "if", "pending_request", ".", "response_handler", "true", "end" ]

[ "Deliver", "the", "response", "and", "remove", "associated", "non", "-", "push", "requests", "from", "pending", "including", "all", "associated", "retry", "requests" ]

[ "def", "init", "(", "auth_client", ",", "options", "=", "{", "}", ")", "raise", "ArgumentError", ",", "\"No authorization client provided\"", "unless", "auth_client", ".", "is_a?", "(", "AuthClient", ")", "@status", "=", "{", "}", "callback", "=", "lambda", "{", "|", "type", ",", "state", "|", "update_status", "(", "type", ",", "state", ")", "}", "@auth", "=", "auth_client", "@status", "[", ":auth", "]", "=", "@auth", ".", "status", "(", "callback", ")", "@router", "=", "RouterClient", ".", "new", "(", "@auth", ",", "options", ")", "@status", "[", ":router", "]", "=", "@router", ".", "status", "(", "callback", ")", "if", "@auth", ".", "api_url", "@api", "=", "ApiClient", ".", "new", "(", "@auth", ",", "options", ")", "@status", "[", ":api", "]", "=", "@api", ".", "status", "(", "callback", ")", "end", "true", "end" ]

[ "Initialize", "RightNet", "client", "Must", "be", "called", "before", "any", "other", "functions", "are", "usable" ]

[ "def", "push", "(", "type", ",", "payload", "=", "nil", ",", "target", "=", "nil", ",", "options", "=", "{", "}", ")", "raise", "RuntimeError", ",", "\"#{self.class.name}#init was not called\"", "unless", "@auth", "client", "=", "(", "@api", "&&", "@api", ".", "support?", "(", "type", ")", ")", "?", "@api", ":", "@router", "client", ".", "push", "(", "type", ",", "payload", ",", "target", ",", "options", ")", "end" ]

[ "Route", "a", "request", "to", "a", "single", "target", "or", "multiple", "targets", "with", "no", "response", "expected", "Persist", "the", "request", "en", "route", "to", "reduce", "the", "chance", "of", "it", "being", "lost", "at", "the", "expense", "of", "some", "additional", "network", "overhead", "Enqueue", "the", "request", "if", "the", "target", "is", "not", "currently", "available", "Never", "automatically", "retry", "the", "request", "if", "there", "is", "the", "possibility", "of", "it", "being", "duplicated", "Set", "time", "-", "to", "-", "live", "to", "be", "forever" ]

[ "def", "communicated", "(", "types", "=", "[", "]", ",", "&", "callback", ")", "raise", "RuntimeError", ",", "\"#{self.class.name}#init was not called\"", "unless", "@auth", "@auth", ".", "communicated", "(", "callback", ")", "if", "types", ".", "empty?", "||", "types", ".", "include?", "(", ":auth", ")", "@api", ".", "communicated", "(", "callback", ")", "if", "@api", "&&", "(", "types", ".", "empty?", "||", "types", ".", "include?", "(", ":api", ")", ")", "@router", ".", "communicated", "(", "callback", ")", "if", "@router", "&&", "(", "types", ".", "empty?", "||", "types", ".", "include?", "(", ":router", ")", ")", "true", "end" ]

[ "Set", "callback", "for", "each", "successful", "communication", "excluding", "health", "checks" ]

[ "def", "to_s", "@serializer", ".", "dump", "(", "{", "'r_s_version'", "=>", "@r_s_version", ".", "to_s", ",", "'timestamp'", "=>", "@timestamp", ".", "to_i", ".", "to_s", ",", "'iv'", "=>", "Base64", "::", "encode64", "(", "@iv", ")", ".", "chop", ",", "'ciphertext'", "=>", "Base64", "::", "encode64", "(", "@ciphertext", ")", ".", "chop", ",", "'mac'", "=>", "Base64", "::", "encode64", "(", "@mac", ")", ".", "chop", "}", ")", "end" ]

[ "Create", "a", "new", "instance", "of", "this", "class" ]

[ "def", "check_authorized", "if", "state", "==", ":expired", "raise", "Exceptions", "::", "RetryableError", ",", "\"Authorization expired\"", "elsif", "state", "!=", ":authorized", "raise", "Exceptions", "::", "Unauthorized", ",", "\"Not authorized with RightScale\"", "if", "state", "!=", ":authorized", "end", "true", "end" ]

[ "Check", "whether", "authorized" ]

[ "def", "to_scraper_hash", "repo", "=", "{", "}", "repo", "[", ":repo_type", "]", "=", "repo_type", ".", "to_sym", "unless", "repo_type", ".", "nil?", "repo", "[", ":url", "]", "=", "url", "repo", "[", ":tag", "]", "=", "tag", "repo", "[", ":resources_path", "]", "=", "cookbooks_path", "if", "!", "ssh_key", ".", "nil?", "repo", "[", ":first_credential", "]", "=", "ssh_key", "elsif", "!", "(", "username", ".", "nil?", "&&", "password", ".", "nil?", ")", "repo", "[", ":first_credential", "]", "=", "dev_repo", ".", "username", "repo", "[", ":second_credential", "]", "=", "dev_repo", ".", "password", "end", "repo", "end" ]

[ "Maps", "the", "given", "DevRepository", "to", "a", "has", "that", "can", "be", "consumed", "by", "the", "RightScraper", "gem" ]