_id
stringlengths 2
6
| title
stringlengths 9
130
| partition
stringclasses 3
values | text
stringlengths 66
10.5k
| language
stringclasses 1
value | meta_information
dict |
|---|---|---|---|---|---|
q23400 | JGrep.Scanner.get_token | train | def get_token
return nil if @token_index >= @arguments.size
begin
case chr(@arguments[@token_index])
when "["
return "statement", gen_substatement
when "]"
return "]"
when "("
return "(", "("
when ")"
return ")", ")"
when "n"
if (chr(@arguments[@token_index + 1]) == "o") && (chr(@arguments[@token_index + 2]) == "t") && ((chr(@arguments[@token_index + 3]) == " ") || (chr(@arguments[@token_index + 3]) == "("))
@token_index += 2
return "not", "not"
else
gen_statement
end
when "!"
return "not", "not"
when "a"
if (chr(@arguments[@token_index + 1]) == "n") && (chr(@arguments[@token_index + 2]) == "d") && ((chr(@arguments[@token_index + 3]) == " ") || (chr(@arguments[@token_index + 3]) == "("))
@token_index += 2
return "and", "and"
else
gen_statement
end
when "&"
if chr(@arguments[@token_index + 1]) == "&"
@token_index += 1
return "and", "and"
else
gen_statement
end
when "o"
if (chr(@arguments[@token_index + 1]) == "r") && ((chr(@arguments[@token_index + 2]) == " ") || (chr(@arguments[@token_index + 2]) == "("))
@token_index += 1
return "or", "or"
else
gen_statement
end
when "|"
if chr(@arguments[@token_index + 1]) == "|"
@token_index += 1
return "or", "or"
else
gen_statement
end
when "+"
value = ""
i = @token_index + 1
begin
value += chr(@arguments[i])
i += 1
end until (i >= @arguments.size) || (chr(@arguments[i]) =~ /\s|\)/)
@token_index = i - 1
return "+", value
when "-"
value = ""
i = @token_index + 1
begin
value += chr(@arguments[i])
i += 1
end until (i >= @arguments.size) || (chr(@arguments[i]) =~ /\s|\)/)
@token_index = i - 1
return "-", value
when " "
return " ", " "
else
gen_statement
end
end
rescue NoMethodError
raise "Error. Expression cannot be parsed."
end | ruby | {
"resource": ""
} |
q23401 | ArgParser.Definition.<< | train | def <<(arg)
case arg
when PositionalArgument, KeywordArgument, FlagArgument, RestArgument
if @arguments[arg.key]
raise ArgumentError, "An argument with key '#{arg.key}' has already been defined"
end
if arg.short_key && @short_keys[arg.short_key]
raise ArgumentError, "The short key '#{arg.short_key}' has already been registered by the '#{
@short_keys[arg.short_key]}' argument"
end
if arg.is_a?(RestArgument) && rest_args
raise ArgumentError, "Only one rest argument can be defined"
end
@arguments[arg.key] = arg
@short_keys[arg.short_key] = arg if arg.short_key
else
raise ArgumentError, "arg must be an instance of PositionalArgument, KeywordArgument, " +
"FlagArgument or RestArgument"
end
end | ruby | {
"resource": ""
} |
q23402 | ArgParser.Definition.positional_arg | train | def positional_arg(key, desc, opts = {}, &block)
self << ArgParser::PositionalArgument.new(key, desc, opts, &block)
end | ruby | {
"resource": ""
} |
q23403 | ArgParser.Definition.keyword_arg | train | def keyword_arg(key, desc, opts = {}, &block)
self << ArgParser::KeywordArgument.new(key, desc, opts, &block)
end | ruby | {
"resource": ""
} |
q23404 | ArgParser.Definition.flag_arg | train | def flag_arg(key, desc, opts = {}, &block)
self << ArgParser::FlagArgument.new(key, desc, opts, &block)
end | ruby | {
"resource": ""
} |
q23405 | ArgParser.Definition.rest_arg | train | def rest_arg(key, desc, opts = {}, &block)
self << ArgParser::RestArgument.new(key, desc, opts, &block)
end | ruby | {
"resource": ""
} |
q23406 | ArgParser.Definition.validate_requirements | train | def validate_requirements(args)
errors = []
@require_set.each do |req, sets|
sets.each do |set|
count = set.count{ |arg| args.has_key?(arg.key) && args[arg.key] }
case req
when :one
if count == 0
errors << "No argument has been specified for one of: #{set.join(', ')}"
elsif count > 1
errors << "Only one argument can been specified from: #{set.join(', ')}"
end
when :any
if count == 0
errors << "At least one of the arguments must be specified from: #{set.join(', ')}"
end
end
end
end
errors
end | ruby | {
"resource": ""
} |
q23407 | ArgParser.Definition.show_usage | train | def show_usage(out = STDERR, width = 80)
lines = ['']
pos_args = positional_args
opt_args = size - pos_args.size
usage_args = pos_args.map(&:to_use)
usage_args << (requires_some? ? 'OPTIONS' : '[OPTIONS]') if opt_args > 0
usage_args << rest_args.to_use if rest_args?
lines.concat(wrap_text("USAGE: #{RUBY_ENGINE} #{$0} #{usage_args.join(' ')}", width))
lines << ''
lines << 'Specify the /? or --help option for more detailed help'
lines << ''
lines.each{ |line| out.puts line } if out
lines
end | ruby | {
"resource": ""
} |
q23408 | ArgParser.Definition.show_help | train | def show_help(out = STDOUT, width = 80)
lines = ['', '']
lines << title
lines << title.gsub(/./, '=')
lines << ''
if purpose
lines.concat(wrap_text(purpose, width))
lines << ''
end
if copyright
lines.concat(wrap_text("Copyright (c) #{copyright}", width))
lines << ''
end
lines << 'USAGE'
lines << '-----'
pos_args = positional_args
opt_args = size - pos_args.size
usage_args = pos_args.map(&:to_use)
usage_args << (requires_some? ? 'OPTIONS' : '[OPTIONS]') if opt_args > 0
usage_args << rest_args.to_use if rest_args?
lines.concat(wrap_text(" #{RUBY_ENGINE} #{$0} #{usage_args.join(' ')}", width))
lines << ''
if positional_args?
max = positional_args.map{ |a| a.to_s.length }.max
pos_args = positional_args
pos_args << rest_args if rest_args?
pos_args.each do |arg|
if arg.usage_break
lines << ''
lines << arg.usage_break
end
desc = arg.description
desc << "\n[Default: #{arg.default}]" unless arg.default.nil?
wrap_text(desc, width - max - 6).each_with_index do |line, i|
lines << " %-#{max}s %s" % [[arg.to_s][i], line]
end
end
lines << ''
end
if non_positional_args?
lines << ''
lines << 'OPTIONS'
lines << '-------'
max = non_positional_args.map{ |a| a.to_use.length }.max
non_positional_args.each do |arg|
if arg.usage_break
lines << ''
lines << arg.usage_break
end
desc = arg.description
desc << "\n[Default: #{arg.default}]" unless arg.default.nil?
wrap_text(desc, width - max - 6).each_with_index do |line, i|
lines << " %-#{max}s %s" % [[arg.to_use][i], line]
end
end
end
lines << ''
lines.each{ |line| line.length < width ? out.puts(line) : out.print(line) } if out
lines
end | ruby | {
"resource": ""
} |
q23409 | ArgParser.Definition.wrap_text | train | def wrap_text(text, width)
if width > 0 && (text.length > width || text.index("\n"))
lines = []
start, nl_pos, ws_pos, wb_pos, end_pos = 0, 0, 0, 0, text.rindex(/[^\s]/)
while start < end_pos
last_start = start
nl_pos = text.index("\n", start)
ws_pos = text.rindex(/ +/, start + width)
wb_pos = text.rindex(/[\-,.;#)}\]\/\\]/, start + width - 1)
### Debug code ###
#STDERR.puts self
#ind = ' ' * end_pos
#ind[start] = '('
#ind[start+width < end_pos ? start+width : end_pos] = ']'
#ind[nl_pos] = 'n' if nl_pos
#ind[wb_pos] = 'b' if wb_pos
#ind[ws_pos] = 's' if ws_pos
#STDERR.puts ind
### End debug code ###
if nl_pos && nl_pos <= start + width
lines << text[start...nl_pos].strip
start = nl_pos + 1
elsif end_pos < start + width
lines << text[start..end_pos]
start = end_pos
elsif ws_pos && ws_pos > start && ((wb_pos.nil? || ws_pos > wb_pos) ||
(wb_pos && wb_pos > 5 && wb_pos - 5 < ws_pos))
lines << text[start...ws_pos]
start = text.index(/[^\s]/, ws_pos + 1)
elsif wb_pos && wb_pos > start
lines << text[start..wb_pos]
start = wb_pos + 1
else
lines << text[start...(start+width)]
start += width
end
if start <= last_start
# Detect an infinite loop, and just return the original text
STDERR.puts "Inifinite loop detected at #{__FILE__}:#{__LINE__}"
STDERR.puts " width: #{width}, start: #{start}, nl_pos: #{nl_pos}, " +
"ws_pos: #{ws_pos}, wb_pos: #{wb_pos}"
return [text]
end
end
lines
else
[text]
end
end | ruby | {
"resource": ""
} |
q23410 | ArgParser.Parser.parse | train | def parse(tokens = ARGV)
@show_usage = nil
@show_help = nil
@errors = []
begin
pos_vals, kw_vals, rest_vals = classify_tokens(tokens)
args = process_args(pos_vals, kw_vals, rest_vals) unless @show_help
rescue NoSuchArgumentError => ex
self.errors << ex.message
@show_usage = true
end
(@show_usage || @show_help) ? false : args
end | ruby | {
"resource": ""
} |
q23411 | ArgParser.Parser.process_arg_val | train | def process_arg_val(arg, val, hsh, is_default = false)
if is_default && arg.required? && (val.nil? || val.empty?)
self.errors << "No value was specified for required argument '#{arg}'"
return
end
if !is_default && val.nil? && KeywordArgument === arg
if arg.value_optional?
val = arg.value_optional
else
self.errors << "No value was specified for keyword argument '#{arg}'"
return
end
end
# Argument value validation
if ValueArgument === arg && arg.validation && val
case arg.validation
when Regexp
[val].flatten.each do |v|
add_value_error(arg, val) unless v =~ arg.validation
end
when Array
[val].flatten.each do |v|
add_value_error(arg, val) unless arg.validation.include?(v)
end
when Proc
begin
arg.validation.call(val, arg, hsh)
rescue StandardError => ex
self.errors << "An error occurred in the validation handler for argument '#{arg}': #{ex}"
return
end
else
raise "Unknown validation type: #{arg.validation.class.name}"
end
end
# TODO: Argument value coercion
# Call any registered on_parse handler
begin
val = arg.on_parse.call(val, arg, hsh) if val && arg.on_parse
rescue StandardError => ex
self.errors << "An error occurred in the on_parse handler for argument '#{arg}': #{ex}"
return
end
# Return result
val
end | ruby | {
"resource": ""
} |
q23412 | Postcodes.Base.method_missing | train | def method_missing(name, *args, &block)
return @info[name.to_s] if @info.key? name.to_s
return @info[name] if @info.key? name
super.method_missing name
end | ruby | {
"resource": ""
} |
q23413 | Resque.JRubyWorker.prune_dead_workers | train | def prune_dead_workers
all_workers = self.class.all
return if all_workers.empty?
known_workers = JRUBY ? worker_thread_ids : []
pids = nil, hostname = self.hostname
all_workers.each do |worker|
host, pid, thread, queues = self.class.split_id(worker.id)
next if host != hostname
next if known_workers.include?(thread) && pid == self.pid.to_s
# NOTE: allow flexibility of running workers :
# 1. worker might run in another JVM instance
# 2. worker might run as a process (with MRI)
next if (pids ||= system_pids).include?(pid)
log! "Pruning dead worker: #{worker}"
if worker.respond_to?(:unregister_worker)
worker.unregister_worker
else # Resque 2.x
Registry.for(worker).unregister
end
end
end | ruby | {
"resource": ""
} |
q23414 | Resque.JRubyWorker.worker_thread_ids | train | def worker_thread_ids
thread_group = java.lang.Thread.currentThread.getThreadGroup
threads = java.lang.reflect.Array.newInstance(
java.lang.Thread.java_class, thread_group.activeCount)
thread_group.enumerate(threads)
# NOTE: we shall check the name from $servlet_context.getServletContextName
# but that's an implementation detail of the factory currently that threads
# are named including their context name. thread grouping should be fine !
threads.map do |thread| # a convention is to name threads as "worker" :
thread && thread.getName.index(WORKER_THREAD_ID) ? thread.getName : nil
end.compact
end | ruby | {
"resource": ""
} |
q23415 | Resque.JRubyWorker.update_native_thread_name | train | def update_native_thread_name
thread = JRuby.reference(Thread.current)
set_thread_name = Proc.new do |prefix, suffix|
self.class.with_global_lock do
count = self.class.system_registered_workers.size
thread.native_thread.name = "#{prefix}##{count}#{suffix}"
end
end
if ! name = thread.native_thread.name
# "#{THREAD_ID}##{count}" :
set_thread_name.call(WORKER_THREAD_ID, nil)
elsif ! name.index(WORKER_THREAD_ID)
# "#{name}(#{THREAD_ID}##{count})" :
set_thread_name.call("#{name} (#{WORKER_THREAD_ID}", ')')
end
end | ruby | {
"resource": ""
} |
q23416 | Resque.JRubyWorker.system_unregister_worker | train | def system_unregister_worker # :nodoc
self.class.with_global_lock do
workers = self.class.system_registered_workers
workers.delete(self.id)
self.class.store_global_property(WORKERS_KEY, workers.join(','))
end
end | ruby | {
"resource": ""
} |
q23417 | Ngannotate.ProcessorCommon.parse_ngannotate_options | train | def parse_ngannotate_options
opt = config.options.clone
if ENV['NG_OPT']
opt_str = ENV['NG_OPT']
if opt_str
opt = Hash[opt_str.split(',').map { |e| e.split('=') }]
opt.symbolize_keys!
end
end
regexp = ENV['NG_REGEXP']
if regexp
opt[:regexp] = regexp
end
opt
end | ruby | {
"resource": ""
} |
q23418 | Spiceweasel.Knife.validate | train | def validate(command, allknifes)
return if allknifes.index { |x| x.start_with?("knife #{command}") }
STDERR.puts "ERROR: 'knife #{command}' is not a currently supported command for knife."
exit(-1)
end | ruby | {
"resource": ""
} |
q23419 | Guacamole.DocumentModelMapper.document_to_model | train | def document_to_model(document)
identity_map.retrieve_or_store model_class, document.key do
model = model_class.new(document.to_h)
model.key = document.key
model.rev = document.revision
handle_related_documents(model)
model
end
end | ruby | {
"resource": ""
} |
q23420 | Guacamole.DocumentModelMapper.model_to_document | train | def model_to_document(model)
document = model.attributes.dup.except(:key, :rev)
handle_embedded_models(model, document)
handle_related_models(document)
document
end | ruby | {
"resource": ""
} |
q23421 | TrustyCms.Initializer.initialize_metal | train | def initialize_metal
Rails::Rack::Metal.requested_metals = configuration.metals
Rails::Rack::Metal.metal_paths = ["#{TRUSTY_CMS_ROOT}/app/metal"] # reset Rails default to TRUSTY_CMS_ROOT
Rails::Rack::Metal.metal_paths += plugin_loader.engine_metal_paths
Rails::Rack::Metal.metal_paths += extension_loader.paths(:metal)
Rails::Rack::Metal.metal_paths.uniq!
configuration.middleware.insert_before(
:"ActionController::ParamsParser",
Rails::Rack::Metal, :if => Rails::Rack::Metal.metals.any?)
end | ruby | {
"resource": ""
} |
q23422 | TrustyCms.Initializer.initialize_i18n | train | def initialize_i18n
radiant_locale_paths = Dir[File.join(TRUSTY_CMS_ROOT, 'config', 'locales', '*.{rb,yml}')]
configuration.i18n.load_path = radiant_locale_paths + extension_loader.paths(:locale)
super
end | ruby | {
"resource": ""
} |
q23423 | Spiceweasel.Nodes.validate_run_list | train | def validate_run_list(node, run_list, cookbooks, roles)
run_list.split(",").each do |item|
if item.start_with?("recipe[")
# recipe[foo] or recipe[foo::bar]
cb = item.split(/\[|\]/)[1].split(":")[0]
unless cookbooks.member?(cb)
STDERR.puts "ERROR: '#{node}' run list cookbook '#{cb}' is missing from the list of cookbooks in the manifest."
exit(-1)
end
elsif item.start_with?("role[")
# role[blah]
role = item.split(/\[|\]/)[1]
unless roles.member?(role)
STDERR.puts "ERROR: '#{node}' run list role '#{role}' is missing from the list of roles in the manifest."
exit(-1)
end
else
STDERR.puts "ERROR: '#{node}' run list '#{item}' is an invalid run list entry in the manifest."
exit(-1)
end
end
end | ruby | {
"resource": ""
} |
q23424 | Spiceweasel.Nodes.validate_options | train | def validate_options(node, options, environments)
if options =~ /-E/ # check for environments
env = options.split("-E")[1].split[0]
unless environments.member?(env)
STDERR.puts "ERROR: '#{node}' environment '#{env}' is missing from the list of environments in the manifest."
exit(-1)
end
end
end | ruby | {
"resource": ""
} |
q23425 | Spiceweasel.Nodes.validate_node_file | train | def validate_node_file(name)
# read in the file
node = Chef::JSONCompat.from_json(IO.read("nodes/#{name}.json"))
# check the node name vs. contents of the file
return unless node["name"] != name
STDERR.puts "ERROR: Node '#{name}' listed in the manifest does not match the name '#{node['name']}' within the nodes/#{name}.json file."
exit(-1)
end | ruby | {
"resource": ""
} |
q23426 | Spiceweasel.Nodes.process_providers | train | def process_providers(names, count, name, options, run_list, create_command_options, knifecommands) # rubocop:disable CyclomaticComplexity
provider = names[0]
validate_provider(provider, names, count, options, knifecommands) unless Spiceweasel::Config[:novalidation]
provided_names = []
if name.nil? && options.split.index("-N") # pull this out for deletes
name = options.split[options.split.index("-N") + 1]
count.to_i.times { |i| provided_names << node_numerate(name, i + 1, count) } if name
end
# google can have names or numbers
if provider.eql?("google") && names[1].to_i == 0
do_google_numeric_provider(create_command_options, names, options, provided_names, run_list)
elsif Spiceweasel::Config[:parallel]
process_parallel(count, create_command_options, name, options, provider, run_list)
else
determine_cloud_provider(count, create_command_options, name, options, provider, run_list)
end
if Spiceweasel::Config[:bulkdelete] && provided_names.empty?
do_bulk_delete(provider)
else
provided_names.each do |p_name|
do_provided_names(p_name, provider)
end
end
end | ruby | {
"resource": ""
} |
q23427 | Spiceweasel.Nodes.validate_provider | train | def validate_provider(provider, names, _count, options, knifecommands)
unless knifecommands.index { |x| x.start_with?("knife #{provider}") }
STDERR.puts "ERROR: 'knife #{provider}' is not a currently installed plugin for knife."
exit(-1)
end
return unless provider.eql?("google")
return unless names[1].to_i != 0 && !options.split.member?("-N")
STDERR.puts "ERROR: 'knife google' currently requires providing a name. Please use -N within the options."
exit(-1)
end | ruby | {
"resource": ""
} |
q23428 | Spiceweasel.Nodes.chef_client_search | train | def chef_client_search(name, run_list, environment)
search = []
search.push("name:#{name}") if name
search.push("chef_environment:#{environment}") if environment
run_list.split(",").each do |item|
item.sub!(/\[/, ":")
item.chop!
item.sub!(/::/, '\:\:')
search.push(item)
end
"#{search.join(' AND ')}"
end | ruby | {
"resource": ""
} |
q23429 | Spiceweasel.Cookbooks.validate_metadata | train | def validate_metadata(cookbook, version)
# check metadata.rb for requested version
metadata = @loader.cookbooks_by_name[cookbook].metadata
Spiceweasel::Log.debug("validate_metadata: #{cookbook} #{metadata.name} #{metadata.version}")
# Should the cookbook directory match the name in the metadata?
if metadata.name.empty?
Spiceweasel::Log.warn("No cookbook name in the #{cookbook} metadata.rb.")
elsif cookbook != metadata.name
STDERR.puts "ERROR: Cookbook '#{cookbook}' does not match the name '#{metadata.name}' in #{cookbook}/metadata.rb."
exit(-1)
end
if version && metadata.version != version
STDERR.puts "ERROR: Invalid version '#{version}' of '#{cookbook}' requested, '#{metadata.version}' is already in the cookbooks directory."
exit(-1)
end
metadata.dependencies.each do |dependency|
Spiceweasel::Log.debug("cookbook #{cookbook} metadata dependency: #{dependency}")
@dependencies.push(dependency[0])
end
end | ruby | {
"resource": ""
} |
q23430 | Spiceweasel.Cookbooks.validate_dependencies | train | def validate_dependencies
Spiceweasel::Log.debug("cookbook validate_dependencies: '#{@dependencies}'")
@dependencies.each do |dep|
unless member?(dep)
STDERR.puts "ERROR: Cookbook dependency '#{dep}' is missing from the list of cookbooks in the manifest."
exit(-1)
end
end
end | ruby | {
"resource": ""
} |
q23431 | Renogen.Generator.generate! | train | def generate!
changelog = extraction_stratagy.extract
changelog.version = version
changelog.date = options['release_date']
writer.write!(changelog)
end | ruby | {
"resource": ""
} |
q23432 | Guacamole.AqlQuery.perfom_query | train | def perfom_query(iterator_with_mapping, &block)
iterator = perform_mapping? ? iterator_with_mapping : iterator_without_mapping(&block)
connection.execute(aql_string, options).each(&iterator)
end | ruby | {
"resource": ""
} |
q23433 | Spiceweasel.Clusters.cluster_process_nodes | train | def cluster_process_nodes(cluster, environment, cookbooks, environments, roles, knifecommands, rootoptions)
Spiceweasel::Log.debug("cluster::cluster_process_nodes '#{environment}' '#{cluster[environment]}'")
cluster[environment].each do |node|
node_name = node.keys.first
options = node[node_name]["options"] || ""
validate_environment(options, environment, environments) unless Spiceweasel::Config[:novalidation]
# push the Environment back on the options
node[node_name]["options"] = options + " -E #{environment}"
end
# let's reuse the Nodes logic
nodes = Spiceweasel::Nodes.new(cluster[environment], cookbooks, environments, roles, knifecommands, rootoptions)
@create.concat(nodes.create)
# what about providers??
nodes.delete.each do |del|
@delete.push(del) unless del.to_s =~ /^knife client|^knife node/
end
if bundler?
@delete.push(Command.new("for N in $(bundle exec knife node list -E #{environment}); do bundle exec knife client delete $N -y; bundle exec knife node delete $N -y; done"))
else
@delete.push(Command.new("for N in $(knife node list -E #{environment}); do knife client delete $N -y; knife node delete $N -y; done"))
end
end | ruby | {
"resource": ""
} |
q23434 | TrustyCms.ExtensionLoader.activate_extensions | train | def activate_extensions
initializer.initialize_views
ordered_extensions = []
configuration = TrustyCms::Application.config
if configuration.extensions.first == :all
ordered_extensions = extensions
else
configuration.extensions.each {|name| ordered_extensions << select_extension(name) }
end
ordered_extensions.flatten.each(&:activate)
Page.load_subclasses
end | ruby | {
"resource": ""
} |
q23435 | Jekyll.JekyllAppEngine.source_partial_exists? | train | def source_partial_exists?
if @site.respond_to?(:in_source_dir)
File.exists? @site.in_source_dir("_app.yaml")
else
File.exists? Jekyll.sanitized_path(@site.source, "_app.yaml")
end
end | ruby | {
"resource": ""
} |
q23436 | Jekyll.JekyllAppEngine.document_overrides | train | def document_overrides(document)
if document.respond_to?(:data) and document.data.has_key?("app_engine")
document.data.fetch("app_engine")
else
{}
end
end | ruby | {
"resource": ""
} |
q23437 | Jekyll.JekyllAppEngine.app_yaml_exists? | train | def app_yaml_exists?
if @site.respond_to?(:in_source_dir)
File.exists? @site.in_source_dir("app.yaml")
else
File.exists? Jekyll.sanitized_path(@site.source, "app.yaml")
end
end | ruby | {
"resource": ""
} |
q23438 | Spiceweasel.DataBags.validate_item | train | def validate_item(db, item)
unless File.exist?("data_bags/#{db}/#{item}.json")
STDERR.puts "ERROR: data bag '#{db}' item '#{item}' file 'data_bags/#{db}/#{item}.json' does not exist"
exit(-1)
end
f = File.read("data_bags/#{db}/#{item}.json")
begin
itemfile = JSON.parse(f)
rescue JSON::ParserError => e # invalid JSON
STDERR.puts "ERROR: data bag '#{db} item '#{item}' has JSON errors."
STDERR.puts e.message
exit(-1)
end
# validate the id matches the file name
item = item.split("/").last if item =~ /\// # pull out directories
return if item.eql?(itemfile["id"])
STDERR.puts "ERROR: data bag '#{db}' item '#{item}' listed in the manifest does not match the id '#{itemfile['id']}' within the 'data_bags/#{db}/#{item}.json' file."
exit(-1)
end | ruby | {
"resource": ""
} |
q23439 | Coercible.Coercer.initialize_coercer | train | def initialize_coercer(klass)
coercers[klass] =
begin
coercer = Coercer::Object.determine_type(klass) || Coercer::Object
args = [ self ]
args << config_for(coercer) if coercer.respond_to?(:config_name)
coercer.new(*args)
end
end | ruby | {
"resource": ""
} |
q23440 | Guacamole.Transaction.write_collections | train | def write_collections
edge_collections.flat_map do |target_state|
[target_state.edge_collection_name] +
(target_state.from_vertices + target_state.to_vertices).map(&:collection)
end.uniq.compact
end | ruby | {
"resource": ""
} |
q23441 | Guacamole.Transaction.transaction | train | def transaction
transaction = database.create_transaction(transaction_code,
write: write_collections,
read: read_collections)
transaction.wait_for_sync = true
transaction
end | ruby | {
"resource": ""
} |
q23442 | PDUTools.Helpers.decode16bit | train | def decode16bit data, length
data.split('').in_groups_of(4).collect()
double_octets = data.split('').in_groups_of(4).map(&:join).map{|x| x.to_i(16) }[0, length / 2] # integer values
double_octets.collect do |o|
[o].pack('S')
end.join.force_encoding('utf-16le').encode('utf-8')
end | ruby | {
"resource": ""
} |
q23443 | Guacamole.Query.each | train | def each(&block)
return to_enum(__callee__) unless block_given?
perfom_query ->(document) { block.call mapper.document_to_model(document) }, &block
end | ruby | {
"resource": ""
} |
q23444 | Guacamole.Query.perfom_query | train | def perfom_query(iterator, &block)
if example
connection.by_example(example, options).each(&iterator)
else
connection.all(options).each(&iterator)
end
end | ruby | {
"resource": ""
} |
q23445 | Mapnik.Map.style | train | def style(name)
style = Mapnik::Style.new
yield style
styles[name] = style
end | ruby | {
"resource": ""
} |
q23446 | Mapnik.Map.layer | train | def layer(name, srs = nil)
layer = Mapnik::Layer.new(name, srs)
layer.map = self
yield layer
layers << layer
end | ruby | {
"resource": ""
} |
q23447 | Mapnik.Map.render_to_file | train | def render_to_file(filename, format = nil)
if format
__render_to_file_with_format__(filename, format)
else
__render_to_file__(filename)
end
return File.exists?(filename)
end | ruby | {
"resource": ""
} |
q23448 | Rfm.Error.getError | train | def getError(code, message=nil)
klass = find_by_code(code)
message = build_message(klass, code, message)
error = klass.new(code, message)
error
end | ruby | {
"resource": ""
} |
q23449 | Mondo.Client.request | train | def request(method, path, opts = {})
raise ClientError, 'Access token missing' unless @access_token
opts[:headers] = {} if opts[:headers].nil?
opts[:headers]['Accept'] = 'application/json'
opts[:headers]['Content-Type'] = 'application/json' unless method == :get
opts[:headers]['User-Agent'] = user_agent
opts[:headers]['Authorization'] = "Bearer #{@access_token}"
if !opts[:data].nil?
opts[:body] = opts[:data].to_param
puts "SETTING BODY #{opts[:body]}"
opts[:headers]['Content-Type'] = 'application/x-www-form-urlencoded' # sob sob
end
path = URI.encode(path)
resp = connection.run_request(method, path, opts[:body], opts[:headers]) do |req|
req.params = opts[:params] if !opts[:params].nil?
end
response = Response.new(resp)
case response.status
when 301, 302, 303, 307
# TODO
when 200..299, 300..399
# on non-redirecting 3xx statuses, just return the response
response
when 400..599
error = ApiError.new(response)
raise(error, "Status code #{response.status}")
else
error = ApiError.new(response)
raise(error, "Unhandled status code value of #{response.status}")
end
end | ruby | {
"resource": ""
} |
q23450 | Rfm.Server.connect | train | def connect(action, args, options = {})
post = args.merge(expand_options(options)).merge({action => ''})
http_fetch("/fmi/xml/fmresultset.xml", post)
end | ruby | {
"resource": ""
} |
q23451 | CopycopterClient.I18nBackend.available_locales | train | def available_locales
cached_locales = cache.keys.map { |key| key.split('.').first }
(cached_locales + super).uniq.map { |locale| locale.to_sym }
end | ruby | {
"resource": ""
} |
q23452 | RAR.Archive.create! | train | def create!
rar_process = IO.popen command_line
# Wait for the child rar process to finish.
_, status = Process.wait2 rar_process.pid
if status.exitstatus > 1
if message = ExitCodeMessages[status.exitstatus]
raise CommandLineError, message
else
raise CommandLineError, "Unknown exit status: #{status}"
end
else
true
end
end | ruby | {
"resource": ""
} |
q23453 | CopycopterClient.Client.upload | train | def upload(data)
connect do |http|
response = http.post(uri('draft_blurbs'), data.to_json, 'Content-Type' => 'application/json')
check response
log 'Uploaded missing translations'
end
end | ruby | {
"resource": ""
} |
q23454 | CopycopterClient.Client.deploy | train | def deploy
connect do |http|
response = http.post(uri('deploys'), '')
check response
log 'Deployed'
end
end | ruby | {
"resource": ""
} |
q23455 | Hooray.Seek.nodes | train | def nodes
return @nodes if @nodes
@nodes = sweep.map do |k, v|
Node.new(ip: k, mac: Hooray::Local.arp_table[k.to_s], ports: v)
end # .reject { |n| n.mac.nil? } # remove those without mac
end | ruby | {
"resource": ""
} |
q23456 | Hooray.Seek.ping_class | train | def ping_class
return Net::Ping::External unless ports
return Net::Ping::TCP unless @protocol =~ /tcp|udp|http|wmi/
Net::Ping.const_get(@protocol.upcase)
end | ruby | {
"resource": ""
} |
q23457 | Hooray.Seek.scan_bot | train | def scan_bot(ip)
(ports || [nil]).each do |port|
Thread.new do
if ping_class.new(ip.to_s, port, TIMEOUT).ping?
@scan[ip] << port
print '.'
end
end
end
end | ruby | {
"resource": ""
} |
q23458 | Hooray.Seek.sweep | train | def sweep
network.to_range.each do |ip|
@scan[ip] = []
scan_bot(ip)
end
Thread.list.reject { |t| t == Thread.current }.each(&:join)
@scan.reject! { |_k, v| v.empty? }
end | ruby | {
"resource": ""
} |
q23459 | CopycopterClient.Cache.export | train | def export
keys = {}
lock do
@blurbs.sort.each do |(blurb_key, value)|
current = keys
yaml_keys = blurb_key.split('.')
0.upto(yaml_keys.size - 2) do |i|
key = yaml_keys[i]
# Overwrite en.key with en.sub.key
unless current[key].class == Hash
current[key] = {}
end
current = current[key]
end
current[yaml_keys.last] = value
end
end
unless keys.size < 1
keys.to_yaml
end
end | ruby | {
"resource": ""
} |
q23460 | CopycopterClient.Cache.wait_for_download | train | def wait_for_download
if pending?
logger.info 'Waiting for first download'
if logger.respond_to? :flush
logger.flush
end
while pending?
sleep 0.1
end
end
end | ruby | {
"resource": ""
} |
q23461 | RTurk.RegisterHITType.validate | train | def validate
missing_parameters = []
required_fields.each do |param|
missing_parameters << param.to_s unless self.send(param)
end
raise RTurk::MissingParameters, "Parameters: '#{missing_parameters.join(', ')}'" unless missing_parameters.empty?
end | ruby | {
"resource": ""
} |
q23462 | TableHelper.CollectionTable.default_class | train | def default_class
if collection.respond_to?(:proxy_reflection)
collection.proxy_reflection.klass
elsif !collection.empty?
collection.first.class
end
end | ruby | {
"resource": ""
} |
q23463 | TableHelper.RowBuilder.undef_cell | train | def undef_cell(name)
method_name = name.gsub('-', '_')
klass = class << self; self; end
klass.class_eval do
remove_method(method_name)
end
end | ruby | {
"resource": ""
} |
q23464 | TableHelper.Row.cell | train | def cell(name, *args)
name = name.to_s if name
options = args.last.is_a?(Hash) ? args.pop : {}
options[:namespace] = table.object_name
args << options
cell = Cell.new(name, *args)
cells[name] = cell
builder.define_cell(name) if name
cell
end | ruby | {
"resource": ""
} |
q23465 | TableHelper.Header.column | train | def column(*names)
# Clear the header row if this is being customized by the user
unless @customized
@customized = true
clear
end
# Extract configuration
options = names.last.is_a?(Hash) ? names.pop : {}
content = names.last.is_a?(String) ? names.pop : nil
args = [content, options].compact
names.collect! do |name|
column = row.cell(name, *args)
column.content_type = :header
column[:scope] ||= 'col'
column
end
names.length == 1 ? names.first : names
end | ruby | {
"resource": ""
} |
q23466 | TableHelper.Header.html | train | def html
html_options = @html_options.dup
html_options[:style] = 'display: none;' if table.empty? && hide_when_empty
content_tag(tag_name, content, html_options)
end | ruby | {
"resource": ""
} |
q23467 | Aliyun.Service.gen_request_parameters | train | def gen_request_parameters method, params
#add common parameters
params.merge! self.service.default_parameters
params.merge! self.options
params[:Action] = method.to_s
params[:Timestamp] = Time.now.utc.iso8601
params[:SignatureNonce] = SecureRandom.uuid
params[:Signature] = compute_signature params
params
end | ruby | {
"resource": ""
} |
q23468 | Aliyun.Service.compute_signature | train | def compute_signature params
if $DEBUG
puts "keys before sorted: #{params.keys}"
end
sorted_keys = params.keys.sort
if $DEBUG
puts "keys after sorted: #{sorted_keys}"
end
canonicalized_query_string = ""
canonicalized_query_string = sorted_keys.map {|key|
"%s=%s" % [safe_encode(key.to_s), safe_encode(params[key])]
}.join(self.service.separator)
length = canonicalized_query_string.length
string_to_sign = self.service.http_method + self.service.separator + safe_encode('/') + self.service.separator + safe_encode(canonicalized_query_string)
if $DEBUG
puts "string_to_sign is #{string_to_sign}"
end
signature = calculate_signature access_key_secret+"&", string_to_sign
end | ruby | {
"resource": ""
} |
q23469 | Aliyun.Service.calculate_signature | train | def calculate_signature key, string_to_sign
hmac = HMAC::SHA1.new(key)
hmac.update(string_to_sign)
signature = Base64.encode64(hmac.digest).gsub("\n", '')
if $DEBUG
puts "Signature #{signature}"
end
signature
end | ruby | {
"resource": ""
} |
q23470 | SubtitleIt.Subtitle.encode_dump | train | def encode_dump(dump)
dump = dump.read unless dump.is_a?(String)
enc = CharlockHolmes::EncodingDetector.detect(dump)
if enc[:encoding] != 'UTF-8'
puts "Converting `#{enc[:encoding]}` to `UTF-8`".yellow
dump = CharlockHolmes::Converter.convert dump, enc[:encoding], 'UTF-8'
end
dump
end | ruby | {
"resource": ""
} |
q23471 | BlockScore.Collection.create | train | def create(params = {})
fail Error, 'Create parent first' unless parent.id
assoc_params = default_params.merge(params)
add_instance(member_class.create(assoc_params))
end | ruby | {
"resource": ""
} |
q23472 | BlockScore.Collection.retrieve | train | def retrieve(id)
each do |item|
return item if item.id.eql?(id)
end
add_instance(member_class.retrieve(id))
end | ruby | {
"resource": ""
} |
q23473 | BlockScore.Collection.parent_id? | train | def parent_id?(item)
parent.id && item.send(foreign_key).eql?(parent.id)
end | ruby | {
"resource": ""
} |
q23474 | BlockScore.Collection.register_to_parent | train | def register_to_parent(item)
fail Error, 'None belonging' unless parent_id?(item)
ids << item.id
self << item
item
end | ruby | {
"resource": ""
} |
q23475 | TableHelper.Body.build_row | train | def build_row(object, index = table.collection.index(object))
row = BodyRow.new(object, self)
row.alternate = alternate ? index.send("#{alternate}?") : false
@builder.call(row.builder, object, index) if @builder
row.html
end | ruby | {
"resource": ""
} |
q23476 | PokerEngine.Cards.values_desc_by_occurency | train | def values_desc_by_occurency
values = cards.map(&:value)
values.sort do |a, b|
coefficient_occurency = (values.count(a) <=> values.count(b))
coefficient_occurency.zero? ? -(a <=> b) : -coefficient_occurency
end
end | ruby | {
"resource": ""
} |
q23477 | TableHelper.BodyRow.content | train | def content
number_to_skip = 0 # Keeps track of the # of columns to skip
html = ''
table.header.column_names.each do |column|
number_to_skip -= 1 and next if number_to_skip > 0
if cell = @cells[column]
number_to_skip = (cell[:colspan] || 1) - 1
else
cell = Cell.new(column, nil)
end
html << cell.html
end
html
end | ruby | {
"resource": ""
} |
q23478 | Beaker.AwsSdk.kill_instances | train | def kill_instances(instances)
running_instances = instances.compact.select do |instance|
instance_by_id(instance.instance_id).state.name == 'running'
end
instance_ids = running_instances.map(&:instance_id)
return nil if instance_ids.empty?
@logger.notify("aws-sdk: killing EC2 instance(s) #{instance_ids.join(', ')}")
client.terminate_instances(:instance_ids => instance_ids)
nil
end | ruby | {
"resource": ""
} |
q23479 | Beaker.AwsSdk.kill_zombie_volumes | train | def kill_zombie_volumes
# Occasionaly, tearing down ec2 instances leaves orphaned EBS volumes behind -- these stack up quickly.
# This simply looks for EBS volumes that are not in use
@logger.notify("aws-sdk: Kill Zombie Volumes!")
volume_count = 0
regions.each do |region|
@logger.debug "Reviewing: #{region}"
available_volumes = client(region).describe_volumes(
:filters => [
{ :name => 'status', :values => ['available'], }
]
).volumes
available_volumes.each do |volume|
begin
client(region).delete_volume(:volume_id => volume.id)
volume_count += 1
rescue Aws::EC2::Errors::InvalidVolume::NotFound => e
@logger.debug "Failed to remove volume: #{volume.id} #{e}"
end
end
end
@logger.notify "Freed #{volume_count} volume(s)"
end | ruby | {
"resource": ""
} |
q23480 | Beaker.AwsSdk.launch_all_nodes | train | def launch_all_nodes
@logger.notify("aws-sdk: launch all hosts in configuration")
ami_spec = YAML.load_file(@options[:ec2_yaml])["AMI"]
global_subnet_id = @options['subnet_id']
global_subnets = @options['subnet_ids']
if global_subnet_id and global_subnets
raise RuntimeError, 'Config specifies both subnet_id and subnet_ids'
end
no_subnet_hosts = []
specific_subnet_hosts = []
some_subnet_hosts = []
@hosts.each do |host|
if global_subnet_id or host['subnet_id']
specific_subnet_hosts.push(host)
elsif global_subnets
some_subnet_hosts.push(host)
else
no_subnet_hosts.push(host)
end
end
instances = [] # Each element is {:instance => i, :host => h}
begin
@logger.notify("aws-sdk: launch instances not particular about subnet")
launch_nodes_on_some_subnet(some_subnet_hosts, global_subnets, ami_spec,
instances)
@logger.notify("aws-sdk: launch instances requiring a specific subnet")
specific_subnet_hosts.each do |host|
subnet_id = host['subnet_id'] || global_subnet_id
instance = create_instance(host, ami_spec, subnet_id)
instances.push({:instance => instance, :host => host})
end
@logger.notify("aws-sdk: launch instances requiring no subnet")
no_subnet_hosts.each do |host|
instance = create_instance(host, ami_spec, nil)
instances.push({:instance => instance, :host => host})
end
wait_for_status(:running, instances)
rescue Exception => ex
@logger.notify("aws-sdk: exception #{ex.class}: #{ex}")
kill_instances(instances.map{|x| x[:instance]})
raise ex
end
# At this point, all instances should be running since wait
# either returns on success or throws an exception.
if instances.empty?
raise RuntimeError, "Didn't manage to launch any EC2 instances"
end
# Assign the now known running instances to their hosts.
instances.each {|x| x[:host]['instance'] = x[:instance]}
nil
end | ruby | {
"resource": ""
} |
q23481 | Beaker.AwsSdk.wait_for_status_netdev | train | def wait_for_status_netdev()
@hosts.each do |host|
if host['platform'] =~ /f5-|netscaler/
wait_for_status(:running, @hosts)
wait_for_status(nil, @hosts) do |instance|
instance_status_collection = client.describe_instance_status({:instance_ids => [instance.instance_id]})
first_instance = instance_status_collection.first[:instance_statuses].first
first_instance[:instance_status][:status] == "ok" if first_instance
end
break
end
end
end | ruby | {
"resource": ""
} |
q23482 | Beaker.AwsSdk.add_tags | train | def add_tags
@hosts.each do |host|
instance = host['instance']
# Define tags for the instance
@logger.notify("aws-sdk: Add tags for #{host.name}")
tags = [
{
:key => 'jenkins_build_url',
:value => @options[:jenkins_build_url],
},
{
:key => 'Name',
:value => host.name,
},
{
:key => 'department',
:value => @options[:department],
},
{
:key => 'project',
:value => @options[:project],
},
{
:key => 'created_by',
:value => @options[:created_by],
},
]
host[:host_tags].each do |name, val|
tags << { :key => name.to_s, :value => val }
end
client.create_tags(
:resources => [instance.instance_id],
:tags => tags.reject { |r| r[:value].nil? },
)
end
nil
end | ruby | {
"resource": ""
} |
q23483 | Beaker.AwsSdk.modify_network_interface | train | def modify_network_interface
@hosts.each do |host|
instance = host['instance']
host['sg_cidr_ips'] = host['sg_cidr_ips'] || '0.0.0.0/0';
sg_cidr_ips = host['sg_cidr_ips'].split(',')
# Define tags for the instance
@logger.notify("aws-sdk: Update network_interface for #{host.name}")
security_group = ensure_group(instance[:network_interfaces].first, Beaker::EC2Helper.amiports(host), sg_cidr_ips)
ping_security_group = ensure_ping_group(instance[:network_interfaces].first, sg_cidr_ips)
client.modify_network_interface_attribute(
:network_interface_id => "#{instance[:network_interfaces].first[:network_interface_id]}",
:groups => [security_group.group_id, ping_security_group.group_id],
)
end
nil
end | ruby | {
"resource": ""
} |
q23484 | Beaker.AwsSdk.populate_dns | train | def populate_dns
# Obtain the IP addresses and dns_name for each host
@hosts.each do |host|
@logger.notify("aws-sdk: Populate DNS for #{host.name}")
instance = host['instance']
host['ip'] = instance.public_ip_address || instance.private_ip_address
host['private_ip'] = instance.private_ip_address
host['dns_name'] = instance.public_dns_name || instance.private_dns_name
@logger.notify("aws-sdk: name: #{host.name} ip: #{host['ip']} private_ip: #{host['private_ip']} dns_name: #{host['dns_name']}")
end
nil
end | ruby | {
"resource": ""
} |
q23485 | Beaker.AwsSdk.enable_root | train | def enable_root(host)
if host['user'] != 'root'
if host['platform'] =~ /f5-/
enable_root_f5(host)
elsif host['platform'] =~ /netscaler/
enable_root_netscaler(host)
else
copy_ssh_to_root(host, @options)
enable_root_login(host, @options)
host['user'] = 'root'
end
host.close
end
end | ruby | {
"resource": ""
} |
q23486 | Beaker.AwsSdk.ensure_key_pair | train | def ensure_key_pair(region)
pair_name = key_name()
delete_key_pair(region, pair_name)
create_new_key_pair(region, pair_name)
end | ruby | {
"resource": ""
} |
q23487 | Beaker.AwsSdk.delete_key_pair_all_regions | train | def delete_key_pair_all_regions(keypair_name_filter=nil)
region_keypairs_hash = my_key_pairs(keypair_name_filter)
region_keypairs_hash.each_pair do |region, keypair_name_array|
keypair_name_array.each do |keypair_name|
delete_key_pair(region, keypair_name)
end
end
end | ruby | {
"resource": ""
} |
q23488 | Beaker.AwsSdk.my_key_pairs | train | def my_key_pairs(name_filter=nil)
keypairs_by_region = {}
key_name_filter = name_filter ? "#{name_filter}-*" : key_name
regions.each do |region|
keypairs_by_region[region] = client(region).describe_key_pairs(
:filters => [{ :name => 'key-name', :values => [key_name_filter] }]
).key_pairs.map(&:key_name)
end
keypairs_by_region
end | ruby | {
"resource": ""
} |
q23489 | Beaker.AwsSdk.delete_key_pair | train | def delete_key_pair(region, pair_name)
kp = client(region).describe_key_pairs(:key_names => [pair_name]).key_pairs.first
unless kp.nil?
@logger.debug("aws-sdk: delete key pair in region: #{region}")
client(region).delete_key_pair(:key_name => pair_name)
end
rescue Aws::EC2::Errors::InvalidKeyPairNotFound
nil
end | ruby | {
"resource": ""
} |
q23490 | Beaker.AwsSdk.create_new_key_pair | train | def create_new_key_pair(region, pair_name)
@logger.debug("aws-sdk: importing new key pair: #{pair_name}")
client(region).import_key_pair(:key_name => pair_name, :public_key_material => public_key)
begin
client(region).wait_until(:key_pair_exists, { :key_names => [pair_name] }, :max_attempts => 5, :delay => 2)
rescue Aws::Waiters::Errors::WaiterFailed
raise RuntimeError, "AWS key pair #{pair_name} can not be queried, even after import"
end
end | ruby | {
"resource": ""
} |
q23491 | Beaker.AwsSdk.group_id | train | def group_id(ports)
if ports.nil? or ports.empty?
raise ArgumentError, "Ports list cannot be nil or empty"
end
unless ports.is_a? Set
ports = Set.new(ports)
end
# Lolwut, #hash is inconsistent between ruby processes
"Beaker-#{Zlib.crc32(ports.inspect)}"
end | ruby | {
"resource": ""
} |
q23492 | Beaker.AwsSdk.create_ping_group | train | def create_ping_group(region_or_vpc, sg_cidr_ips = ['0.0.0.0/0'])
@logger.notify("aws-sdk: Creating group #{PING_SECURITY_GROUP_NAME}")
cl = region_or_vpc.is_a?(String) ? client(region_or_vpc) : client
params = {
:description => 'Custom Beaker security group to enable ping',
:group_name => PING_SECURITY_GROUP_NAME,
}
params[:vpc_id] = region_or_vpc.vpc_id if region_or_vpc.is_a?(Aws::EC2::Types::Vpc)
group = cl.create_security_group(params)
sg_cidr_ips.each do |cidr_ip|
add_ingress_rule(
cl,
group,
cidr_ip,
'8', # 8 == ICMPv4 ECHO request
'-1', # -1 == All ICMP codes
'icmp',
)
end
group
end | ruby | {
"resource": ""
} |
q23493 | Beaker.AwsSdk.create_group | train | def create_group(region_or_vpc, ports, sg_cidr_ips = ['0.0.0.0/0'])
name = group_id(ports)
@logger.notify("aws-sdk: Creating group #{name} for ports #{ports.to_s}")
@logger.notify("aws-sdk: Creating group #{name} with CIDR IPs #{sg_cidr_ips.to_s}")
cl = region_or_vpc.is_a?(String) ? client(region_or_vpc) : client
params = {
:description => "Custom Beaker security group for #{ports.to_a}",
:group_name => name,
}
params[:vpc_id] = region_or_vpc.vpc_id if region_or_vpc.is_a?(Aws::EC2::Types::Vpc)
group = cl.create_security_group(params)
unless ports.is_a? Set
ports = Set.new(ports)
end
sg_cidr_ips.each do |cidr_ip|
ports.each do |port|
add_ingress_rule(cl, group, cidr_ip, port, port)
end
end
group
end | ruby | {
"resource": ""
} |
q23494 | Beaker.AwsSdk.add_ingress_rule | train | def add_ingress_rule(cl, sg_group, cidr_ip, from_port, to_port, protocol = 'tcp')
cl.authorize_security_group_ingress(
:cidr_ip => cidr_ip,
:ip_protocol => protocol,
:from_port => from_port,
:to_port => to_port,
:group_id => sg_group.group_id,
)
end | ruby | {
"resource": ""
} |
q23495 | Beaker.AwsSdk.load_fog_credentials | train | def load_fog_credentials(dot_fog = '.fog')
default = get_fog_credentials(dot_fog)
raise "You must specify an aws_access_key_id in your .fog file (#{dot_fog}) for ec2 instances!" unless default[:aws_access_key_id]
raise "You must specify an aws_secret_access_key in your .fog file (#{dot_fog}) for ec2 instances!" unless default[:aws_secret_access_key]
Aws::Credentials.new(
default[:aws_access_key_id],
default[:aws_secret_access_key],
default[:aws_session_token]
)
end | ruby | {
"resource": ""
} |
q23496 | RailsApiBenchmark.ResultSet.compute_relative_speed | train | def compute_relative_speed
@results = @results.map do |r|
avgs = averages
res = r[:results]
avg_rt = avgs[:response_time]
avg_rps = avgs[:req_per_sec]
f_rt = ((res[:response_time].to_f - avg_rt) / avg_rt * 100).round(1)
f_rps = ((res[:req_per_sec].to_f - avg_rps) / avg_rps * 100).round(1)
r.merge(factors: { response_time: f_rt, req_per_sec: f_rps })
end
end | ruby | {
"resource": ""
} |
q23497 | Attrio.Helpers.symbolize_hash_keys | train | def symbolize_hash_keys(hash)
hash.inject({}) do |new_hash, (key, value)|
new_hash[(key.to_sym rescue key) || key] = value
new_hash
end
hash
end | ruby | {
"resource": ""
} |
q23498 | FcrepoWrapper.Instance.start | train | def start
extract_and_configure
if config.managed?
@pid = spawn(config.env, *process_arguments)
# Wait for fcrepo to start
while !status
sleep 1
end
end
end | ruby | {
"resource": ""
} |
q23499 | FcrepoWrapper.Instance.stop | train | def stop
if config.managed? && started?
Process.kill 'HUP', pid
# Wait for fcrepo to stop
while status
sleep 1
end
Process.waitpid(pid)
end
@pid = nil
end | ruby | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.