_id stringlengths 2 6 | title stringlengths 9 130 | partition stringclasses 3 values | text stringlengths 66 10.5k | language stringclasses 1 value | meta_information dict |
|---|---|---|---|---|---|
q10900 | Puppet::Util::Windows.Service.exists? | train | def exists?(service_name)
open_service(service_name, SC_MANAGER_CONNECT, SERVICE_QUERY_STATUS) do |_|
true
end
rescue Puppet::Util::Windows::Error => e
return false if e.code == ERROR_SERVICE_DOES_NOT_EXIST
raise e
end | ruby | {
"resource": ""
} |
q10901 | Puppet::Util::Windows.Service.start | train | def start(service_name, timeout: DEFAULT_TIMEOUT)
Puppet.debug _("Starting the %{service_name} service. Timeout set to: %{timeout} seconds") % { service_name: service_name, timeout: timeout }
valid_initial_states = [
SERVICE_STOP_PENDING,
SERVICE_STOPPED,
SERVICE_START_PENDING
]
transition_service_state(service_name, valid_initial_states, SERVICE_RUNNING, timeout) do |service|
if StartServiceW(service, 0, FFI::Pointer::NULL) == FFI::WIN32_FALSE
raise Puppet::Util::Windows::Error, _("Failed to start the service")
end
end
Puppet.debug _("Successfully started the %{service_name} service") % { service_name: service_name }
end | ruby | {
"resource": ""
} |
q10902 | Puppet::Util::Windows.Service.stop | train | def stop(service_name, timeout: DEFAULT_TIMEOUT)
Puppet.debug _("Stopping the %{service_name} service. Timeout set to: %{timeout} seconds") % { service_name: service_name, timeout: timeout }
valid_initial_states = SERVICE_STATES.keys - [SERVICE_STOPPED]
transition_service_state(service_name, valid_initial_states, SERVICE_STOPPED, timeout) do |service|
send_service_control_signal(service, SERVICE_CONTROL_STOP)
end
Puppet.debug _("Successfully stopped the %{service_name} service") % { service_name: service_name }
end | ruby | {
"resource": ""
} |
q10903 | Puppet::Util::Windows.Service.resume | train | def resume(service_name, timeout: DEFAULT_TIMEOUT)
Puppet.debug _("Resuming the %{service_name} service. Timeout set to: %{timeout} seconds") % { service_name: service_name, timeout: timeout }
valid_initial_states = [
SERVICE_PAUSE_PENDING,
SERVICE_PAUSED,
SERVICE_CONTINUE_PENDING
]
transition_service_state(service_name, valid_initial_states, SERVICE_RUNNING, timeout) do |service|
# The SERVICE_CONTROL_CONTINUE signal can only be sent when
# the service is in the SERVICE_PAUSED state
wait_on_pending_state(service, SERVICE_PAUSE_PENDING, timeout)
send_service_control_signal(service, SERVICE_CONTROL_CONTINUE)
end
Puppet.debug _("Successfully resumed the %{service_name} service") % { service_name: service_name }
end | ruby | {
"resource": ""
} |
q10904 | Puppet::Util::Windows.Service.service_state | train | def service_state(service_name)
state = nil
open_service(service_name, SC_MANAGER_CONNECT, SERVICE_QUERY_STATUS) do |service|
query_status(service) do |status|
state = SERVICE_STATES[status[:dwCurrentState]]
end
end
if state.nil?
raise Puppet::Error.new(_("Unknown Service state '%{current_state}' for '%{service_name}'") % { current_state: state.to_s, service_name: service_name})
end
state
end | ruby | {
"resource": ""
} |
q10905 | Puppet::Util::Windows.Service.service_start_type | train | def service_start_type(service_name)
start_type = nil
open_service(service_name, SC_MANAGER_CONNECT, SERVICE_QUERY_CONFIG) do |service|
query_config(service) do |config|
start_type = SERVICE_START_TYPES[config[:dwStartType]]
end
end
if start_type.nil?
raise Puppet::Error.new(_("Unknown start type '%{start_type}' for '%{service_name}'") % { start_type: start_type.to_s, service_name: service_name})
end
start_type
end | ruby | {
"resource": ""
} |
q10906 | Puppet::Util::Windows.Service.set_startup_mode | train | def set_startup_mode(service_name, startup_type)
startup_code = SERVICE_START_TYPES.key(startup_type)
if startup_code.nil?
raise Puppet::Error.new(_("Unknown start type %{start_type}") % {startup_type: startup_type.to_s})
end
open_service(service_name, SC_MANAGER_CONNECT, SERVICE_CHANGE_CONFIG) do |service|
# Currently the only thing puppet's API can really manage
# in this list is dwStartType (the third param). Thus no
# generic function was written to make use of all the params
# since the API as-is couldn't use them anyway
success = ChangeServiceConfigW(
service,
SERVICE_NO_CHANGE, # dwServiceType
startup_code, # dwStartType
SERVICE_NO_CHANGE, # dwErrorControl
FFI::Pointer::NULL, # lpBinaryPathName
FFI::Pointer::NULL, # lpLoadOrderGroup
FFI::Pointer::NULL, # lpdwTagId
FFI::Pointer::NULL, # lpDependencies
FFI::Pointer::NULL, # lpServiceStartName
FFI::Pointer::NULL, # lpPassword
FFI::Pointer::NULL # lpDisplayName
)
if success == FFI::WIN32_FALSE
raise Puppet::Util::Windows::Error.new(_("Failed to update service configuration"))
end
end
end | ruby | {
"resource": ""
} |
q10907 | Puppet::Util::Windows.Service.services | train | def services
services = {}
open_scm(SC_MANAGER_ENUMERATE_SERVICE) do |scm|
size_required = 0
services_returned = 0
FFI::MemoryPointer.new(:dword) do |bytes_pointer|
FFI::MemoryPointer.new(:dword) do |svcs_ret_ptr|
FFI::MemoryPointer.new(:dword) do |resume_ptr|
resume_ptr.write_dword(0)
# Fetch the bytes of memory required to be allocated
# for QueryServiceConfigW to return succesfully. This
# is done by sending NULL and 0 for the pointer and size
# respectively, letting the command fail, then reading the
# value of pcbBytesNeeded
#
# return value will be false from this call, since it's designed
# to fail. Just ignore it
EnumServicesStatusExW(
scm,
:SC_ENUM_PROCESS_INFO,
ALL_SERVICE_TYPES,
SERVICE_STATE_ALL,
FFI::Pointer::NULL,
0,
bytes_pointer,
svcs_ret_ptr,
resume_ptr,
FFI::Pointer::NULL
)
size_required = bytes_pointer.read_dword
FFI::MemoryPointer.new(size_required) do |buffer_ptr|
resume_ptr.write_dword(0)
svcs_ret_ptr.write_dword(0)
success = EnumServicesStatusExW(
scm,
:SC_ENUM_PROCESS_INFO,
ALL_SERVICE_TYPES,
SERVICE_STATE_ALL,
buffer_ptr,
buffer_ptr.size,
bytes_pointer,
svcs_ret_ptr,
resume_ptr,
FFI::Pointer::NULL
)
if success == FFI::WIN32_FALSE
raise Puppet::Util::Windows::Error.new(_("Failed to fetch services"))
end
# Now that the buffer is populated with services
# we pull the data from memory using pointer arithmetic:
# the number of services returned by the function is
# available to be read from svcs_ret_ptr, and we iterate
# that many times moving the cursor pointer the length of
# ENUM_SERVICE_STATUS_PROCESSW.size. This should iterate
# over the buffer and extract each struct.
services_returned = svcs_ret_ptr.read_dword
cursor_ptr = FFI::Pointer.new(ENUM_SERVICE_STATUS_PROCESSW, buffer_ptr)
0.upto(services_returned - 1) do |index|
service = ENUM_SERVICE_STATUS_PROCESSW.new(cursor_ptr[index])
services[service[:lpServiceName].read_arbitrary_wide_string_up_to(SERVICENAME_MAX)] = {
:display_name => service[:lpDisplayName].read_arbitrary_wide_string_up_to(SERVICENAME_MAX),
:service_status_process => service[:ServiceStatusProcess]
}
end
end # buffer_ptr
end # resume_ptr
end # scvs_ret_ptr
end # bytes_ptr
end # open_scm
services
end | ruby | {
"resource": ""
} |
q10908 | Generators.PuppetGenerator.gen_sub_directories | train | def gen_sub_directories
super
File.makedirs(MODULE_DIR)
File.makedirs(NODE_DIR)
File.makedirs(PLUGIN_DIR)
rescue
$stderr.puts $ERROR_INFO.message
exit 1
end | ruby | {
"resource": ""
} |
q10909 | Generators.PuppetGenerator.gen_top_index | train | def gen_top_index(collection, title, template, filename)
template = TemplatePage.new(RDoc::Page::FR_INDEX_BODY, template)
res = []
collection.sort.each do |f|
if f.document_self
res << { "classlist" => CGI.escapeHTML("#{MODULE_DIR}/fr_#{f.index_name}.html"), "module" => CGI.escapeHTML("#{CLASS_DIR}/#{f.index_name}.html"),"name" => CGI.escapeHTML(f.index_name) }
end
end
values = {
"entries" => res,
'list_title' => CGI.escapeHTML(title),
'index_url' => main_url,
'charset' => @options.charset,
'style_url' => style_url('', @options.css),
}
Puppet::FileSystem.open(filename, nil, "w:UTF-8") do |f|
template.write_html_on(f, values)
end
end | ruby | {
"resource": ""
} |
q10910 | Generators.PuppetGenerator.gen_class_index | train | def gen_class_index
gen_an_index(@classes, 'All Classes', RDoc::Page::CLASS_INDEX, "fr_class_index.html")
@allfiles.each do |file|
unless file['file'].context.file_relative_name =~ /\.rb$/
gen_composite_index(
file,
RDoc::Page::COMBO_INDEX,
"#{MODULE_DIR}/fr_#{file["file"].context.module_name}.html")
end
end
end | ruby | {
"resource": ""
} |
q10911 | Generators.PuppetGenerator.main_url | train | def main_url
main_page = @options.main_page
ref = nil
if main_page
ref = AllReferences[main_page]
if ref
ref = ref.path
else
$stderr.puts "Could not find main page #{main_page}"
end
end
unless ref
for file in @files
if file.document_self and file.context.global
ref = CGI.escapeHTML("#{CLASS_DIR}/#{file.context.module_name}.html")
break
end
end
end
unless ref
for file in @files
if file.document_self and !file.context.global
ref = CGI.escapeHTML("#{CLASS_DIR}/#{file.context.module_name}.html")
break
end
end
end
unless ref
$stderr.puts "Couldn't find anything to document"
$stderr.puts "Perhaps you've used :stopdoc: in all classes"
exit(1)
end
ref
end | ruby | {
"resource": ""
} |
q10912 | Generators.HTMLPuppetNode.http_url | train | def http_url(full_name, prefix)
path = full_name.dup
path.gsub!(/<<\s*(\w*)/) { "from-#$1" } if path['<<']
File.join(prefix, path.split("::").collect { |p| Digest::MD5.hexdigest(p) }) + ".html"
end | ruby | {
"resource": ""
} |
q10913 | Puppet::Util::ProviderFeatures.ProviderFeature.methods_available? | train | def methods_available?(obj)
methods.each do |m|
if obj.is_a?(Class)
return false unless obj.public_method_defined?(m)
else
return false unless obj.respond_to?(m)
end
end
true
end | ruby | {
"resource": ""
} |
q10914 | Puppet::ModuleTool.Metadata.update | train | def update(data)
process_name(data) if data['name']
process_version(data) if data['version']
process_source(data) if data['source']
process_data_provider(data) if data['data_provider']
merge_dependencies(data) if data['dependencies']
@data.merge!(data)
return self
end | ruby | {
"resource": ""
} |
q10915 | Puppet::ModuleTool.Metadata.add_dependency | train | def add_dependency(name, version_requirement=nil, repository=nil)
validate_name(name)
validate_version_range(version_requirement) if version_requirement
if dup = @data['dependencies'].find { |d| d.full_module_name == name && d.version_requirement != version_requirement }
raise ArgumentError, _("Dependency conflict for %{module_name}: Dependency %{name} was given conflicting version requirements %{version_requirement} and %{dup_version}. Verify that there are no duplicates in the metadata.json.") % { module_name: full_module_name, name: name, version_requirement: version_requirement, dup_version: dup.version_requirement }
end
dep = Dependency.new(name, version_requirement, repository)
@data['dependencies'].add(dep)
dep
end | ruby | {
"resource": ""
} |
q10916 | Puppet::ModuleTool.Metadata.process_name | train | def process_name(data)
validate_name(data['name'])
author, @module_name = data['name'].split(/[-\/]/, 2)
data['author'] ||= author if @data['author'] == DEFAULTS['author']
end | ruby | {
"resource": ""
} |
q10917 | Puppet::ModuleTool.Metadata.process_source | train | def process_source(data)
if data['source'] =~ %r[://]
source_uri = URI.parse(data['source'])
else
source_uri = URI.parse("http://#{data['source']}")
end
if source_uri.host =~ /^(www\.)?github\.com$/
source_uri.scheme = 'https'
source_uri.path.sub!(/\.git$/, '')
data['project_page'] ||= @data['project_page'] || source_uri.to_s
data['issues_url'] ||= @data['issues_url'] || source_uri.to_s.sub(/\/*$/, '') + '/issues'
end
rescue URI::Error
return
end | ruby | {
"resource": ""
} |
q10918 | Puppet::ModuleTool.Metadata.merge_dependencies | train | def merge_dependencies(data)
data['dependencies'].each do |dep|
add_dependency(dep['name'], dep['version_requirement'], dep['repository'])
end
# Clear dependencies so @data dependencies are not overwritten
data.delete 'dependencies'
end | ruby | {
"resource": ""
} |
q10919 | Puppet::ModuleTool.Metadata.validate_name | train | def validate_name(name)
return if name =~ /\A[a-z0-9]+[-\/][a-z][a-z0-9_]*\Z/i
namespace, modname = name.split(/[-\/]/, 2)
modname = :namespace_missing if namespace == ''
err = case modname
when nil, '', :namespace_missing
_("the field must be a namespaced module name")
when /[^a-z0-9_]/i
_("the module name contains non-alphanumeric (or underscore) characters")
when /^[^a-z]/i
_("the module name must begin with a letter")
else
_("the namespace contains non-alphanumeric characters")
end
raise ArgumentError, _("Invalid 'name' field in metadata.json: %{err}") % { err: err }
end | ruby | {
"resource": ""
} |
q10920 | Puppet::ModuleTool.Metadata.validate_version | train | def validate_version(version)
return if SemanticPuppet::Version.valid?(version)
err = _("version string cannot be parsed as a valid Semantic Version")
raise ArgumentError, _("Invalid 'version' field in metadata.json: %{err}") % { err: err }
end | ruby | {
"resource": ""
} |
q10921 | Puppet::ModuleTool.Metadata.validate_data_provider | train | def validate_data_provider(value)
if value.is_a?(String)
unless value =~ /^[a-zA-Z][a-zA-Z0-9_]*$/
if value =~ /^[a-zA-Z]/
raise ArgumentError, _("field 'data_provider' contains non-alphanumeric characters")
else
raise ArgumentError, _("field 'data_provider' must begin with a letter")
end
end
else
raise ArgumentError, _("field 'data_provider' must be a string")
end
end | ruby | {
"resource": ""
} |
q10922 | Puppet::ModuleTool.Metadata.validate_version_range | train | def validate_version_range(version_range)
SemanticPuppet::VersionRange.parse(version_range)
rescue ArgumentError => e
raise ArgumentError, _("Invalid 'version_range' field in metadata.json: %{err}") % { err: e }
end | ruby | {
"resource": ""
} |
q10923 | Puppet.Network::DefaultAuthProvider.insert_default_acl | train | def insert_default_acl
self.class.default_acl.each do |acl|
unless rights[acl[:acl]]
Puppet.info _("Inserting default '%{acl}' (auth %{auth}) ACL") % { acl: acl[:acl], auth: acl[:authenticated] }
mk_acl(acl)
end
end
# queue an empty (ie deny all) right for every other path
# actually this is not strictly necessary as the rights system
# denies not explicitly allowed paths
unless rights["/"]
rights.newright("/").restrict_authenticated(:any)
end
end | ruby | {
"resource": ""
} |
q10924 | Puppet::Util::Windows::ADSI.User.op_userflags | train | def op_userflags(*flags, &block)
# Avoid an unnecessary set + commit operation.
return if flags.empty?
unrecognized_flags = flags.reject { |flag| ADS_USERFLAGS.keys.include?(flag) }
unless unrecognized_flags.empty?
raise ArgumentError, _("Unrecognized ADS UserFlags: %{unrecognized_flags}") % { unrecognized_flags: unrecognized_flags.join(', ') }
end
self['UserFlags'] = flags.inject(self['UserFlags'], &block)
end | ruby | {
"resource": ""
} |
q10925 | Puppet::Network.Resolver.each_srv_record | train | def each_srv_record(domain, service_name = :puppet, &block)
if (domain.nil? or domain.empty?)
Puppet.debug "Domain not known; skipping SRV lookup"
return
end
Puppet.debug "Searching for SRV records for domain: #{domain}"
case service_name
when :puppet then service = '_x-puppet'
when :file then service = '_x-puppet-fileserver'
else service = "_x-puppet-#{service_name.to_s}"
end
record_name = "#{service}._tcp.#{domain}"
if @record_cache.has_key?(service_name) && !expired?(service_name)
records = @record_cache[service_name].records
Puppet.debug "Using cached record for #{record_name}"
else
records = @resolver.getresources(record_name, Resolv::DNS::Resource::IN::SRV)
if records.size > 0
@record_cache[service_name] = CacheEntry.new(records)
end
Puppet.debug "Found #{records.size} SRV records for: #{record_name}"
end
if records.size == 0 && service_name != :puppet
# Try the generic :puppet service if no SRV records were found
# for the specific service.
each_srv_record(domain, :puppet, &block)
else
each_priority(records) do |recs|
while next_rr = recs.delete(find_weighted_server(recs))
Puppet.debug "Yielding next server of #{next_rr.target.to_s}:#{next_rr.port}"
yield next_rr.target.to_s, next_rr.port
end
end
end
end | ruby | {
"resource": ""
} |
q10926 | Puppet::Network.Resolver.find_weighted_server | train | def find_weighted_server(records)
return nil if records.nil? || records.empty?
return records.first if records.size == 1
# Calculate the sum of all weights in the list of resource records,
# This is used to then select hosts until the weight exceeds what
# random number we selected. For example, if we have weights of 1 8 and 3:
#
# |-|--------|---|
# ^
# We generate a random number 5, and iterate through the records, adding
# the current record's weight to the accumulator until the weight of the
# current record plus previous records is greater than the random number.
total_weight = records.inject(0) { |sum,record|
sum + weight(record)
}
current_weight = 0
chosen_weight = 1 + Kernel.rand(total_weight)
records.each do |record|
current_weight += weight(record)
return record if current_weight >= chosen_weight
end
end | ruby | {
"resource": ""
} |
q10927 | Puppet::Network.Resolver.expired? | train | def expired?(service_name)
if entry = @record_cache[service_name]
return Time.now > (entry.resolution_time + entry.ttl)
else
return true
end
end | ruby | {
"resource": ""
} |
q10928 | Puppet.Util.clear_environment | train | def clear_environment(mode = default_env)
case mode
when :posix
ENV.clear
when :windows
Puppet::Util::Windows::Process.get_environment_strings.each do |key, _|
Puppet::Util::Windows::Process.set_environment_variable(key, nil)
end
else
raise _("Unable to clear the environment for mode %{mode}") % { mode: mode }
end
end | ruby | {
"resource": ""
} |
q10929 | Puppet.Util.which | train | def which(bin)
if absolute_path?(bin)
return bin if FileTest.file? bin and FileTest.executable? bin
else
exts = Puppet::Util.get_env('PATHEXT')
exts = exts ? exts.split(File::PATH_SEPARATOR) : %w[.COM .EXE .BAT .CMD]
Puppet::Util.get_env('PATH').split(File::PATH_SEPARATOR).each do |dir|
begin
dest = File.expand_path(File.join(dir, bin))
rescue ArgumentError => e
# if the user's PATH contains a literal tilde (~) character and HOME is not set, we may get
# an ArgumentError here. Let's check to see if that is the case; if not, re-raise whatever error
# was thrown.
if e.to_s =~ /HOME/ and (Puppet::Util.get_env('HOME').nil? || Puppet::Util.get_env('HOME') == "")
# if we get here they have a tilde in their PATH. We'll issue a single warning about this and then
# ignore this path element and carry on with our lives.
#TRANSLATORS PATH and HOME are environment variables and should not be translated
Puppet::Util::Warnings.warnonce(_("PATH contains a ~ character, and HOME is not set; ignoring PATH element '%{dir}'.") % { dir: dir })
elsif e.to_s =~ /doesn't exist|can't find user/
# ...otherwise, we just skip the non-existent entry, and do nothing.
#TRANSLATORS PATH is an environment variable and should not be translated
Puppet::Util::Warnings.warnonce(_("Couldn't expand PATH containing a ~ character; ignoring PATH element '%{dir}'.") % { dir: dir })
else
raise
end
else
if Puppet::Util::Platform.windows? && File.extname(dest).empty?
exts.each do |ext|
destext = File.expand_path(dest + ext)
return destext if FileTest.file? destext and FileTest.executable? destext
end
end
return dest if FileTest.file? dest and FileTest.executable? dest
end
end
end
nil
end | ruby | {
"resource": ""
} |
q10930 | Puppet.Util.path_to_uri | train | def path_to_uri(path)
return unless path
params = { :scheme => 'file' }
if Puppet::Util::Platform.windows?
path = path.gsub(/\\/, '/')
if unc = /^\/\/([^\/]+)(\/.+)/.match(path)
params[:host] = unc[1]
path = unc[2]
elsif path =~ /^[a-z]:\//i
path = '/' + path
end
end
# have to split *after* any relevant escaping
params[:path], params[:query] = uri_encode(path).split('?')
search_for_fragment = params[:query] ? :query : :path
if params[search_for_fragment].include?('#')
params[search_for_fragment], _, params[:fragment] = params[search_for_fragment].rpartition('#')
end
begin
URI::Generic.build(params)
rescue => detail
raise Puppet::Error, _("Failed to convert '%{path}' to URI: %{detail}") % { path: path, detail: detail }, detail.backtrace
end
end | ruby | {
"resource": ""
} |
q10931 | Puppet.Util.uri_to_path | train | def uri_to_path(uri)
return unless uri.is_a?(URI)
# CGI.unescape doesn't handle space rules properly in uri paths
# URI.unescape does, but returns strings in their original encoding
path = URI.unescape(uri.path.encode(Encoding::UTF_8))
if Puppet::Util::Platform.windows? && uri.scheme == 'file'
if uri.host
path = "//#{uri.host}" + path # UNC
else
path.sub!(/^\//, '')
end
end
path
end | ruby | {
"resource": ""
} |
q10932 | Puppet.Util.exit_on_fail | train | def exit_on_fail(message, code = 1)
yield
# First, we need to check and see if we are catching a SystemExit error. These will be raised
# when we daemonize/fork, and they do not necessarily indicate a failure case.
rescue SystemExit => err
raise err
# Now we need to catch *any* other kind of exception, because we may be calling third-party
# code (e.g. webrick), and we have no idea what they might throw.
rescue Exception => err
## NOTE: when debugging spec failures, these two lines can be very useful
#puts err.inspect
#puts Puppet::Util.pretty_backtrace(err.backtrace)
Puppet.log_exception(err, "#{message}: #{err}")
Puppet::Util::Log.force_flushqueue()
exit(code)
end | ruby | {
"resource": ""
} |
q10933 | Puppet::Pops::Evaluator.Runtime3Converter.map_args | train | def map_args(args, scope, undef_value)
args.map {|a| convert(a, scope, undef_value) }
end | ruby | {
"resource": ""
} |
q10934 | Puppet.Type.delete | train | def delete(attr)
attr = attr.intern
if @parameters.has_key?(attr)
@parameters.delete(attr)
else
raise Puppet::DevError.new(_("Undefined attribute '%{attribute}' in %{name}") % { attribute: attr, name: self})
end
end | ruby | {
"resource": ""
} |
q10935 | Puppet.Type.managed? | train | def managed?
# Once an object is managed, it always stays managed; but an object
# that is listed as unmanaged might become managed later in the process,
# so we have to check that every time
if @managed
return @managed
else
@managed = false
properties.each { |property|
s = property.should
if s and ! property.class.unmanaged
@managed = true
break
end
}
return @managed
end
end | ruby | {
"resource": ""
} |
q10936 | Puppet.Type.retrieve | train | def retrieve
fail "Provider #{provider.class.name} is not functional on this host" if self.provider.is_a?(Puppet::Provider) and ! provider.class.suitable?
result = Puppet::Resource.new(self.class, title)
# Provide the name, so we know we'll always refer to a real thing
result[:name] = self[:name] unless self[:name] == title
if ensure_prop = property(:ensure) or (self.class.needs_ensure_retrieved and self.class.validattr?(:ensure) and ensure_prop = newattr(:ensure))
result[:ensure] = ensure_state = ensure_prop.retrieve
else
ensure_state = nil
end
properties.each do |property|
next if property.name == :ensure
if ensure_state == :absent
result[property] = :absent
else
result[property] = property.retrieve
end
end
result
end | ruby | {
"resource": ""
} |
q10937 | Puppet.Type.builddepends | train | def builddepends
# Handle the requires
self.class.relationship_params.collect do |klass|
if param = @parameters[klass.name]
param.to_edges
end
end.flatten.reject { |r| r.nil? }
end | ruby | {
"resource": ""
} |
q10938 | Puppet.Type.set_sensitive_parameters | train | def set_sensitive_parameters(sensitive_parameters)
sensitive_parameters.each do |name|
p = parameter(name)
if p.is_a?(Puppet::Property)
p.sensitive = true
elsif p.is_a?(Puppet::Parameter)
warning(_("Unable to mark '%{name}' as sensitive: %{name} is a parameter and not a property, and cannot be automatically redacted.") %
{ name: name })
elsif self.class.attrclass(name)
warning(_("Unable to mark '%{name}' as sensitive: the property itself was not assigned a value.") % { name: name })
else
err(_("Unable to mark '%{name}' as sensitive: the property itself is not defined on %{type}.") % { name: name, type: type })
end
end
parameters.each do |name, param|
next if param.sensitive
if param.is_a?(Puppet::Parameter)
param.sensitive = param.is_sensitive if param.respond_to?(:is_sensitive)
end
end
end | ruby | {
"resource": ""
} |
q10939 | Puppet.Type.finish | train | def finish
# Call post_compile hook on every parameter that implements it. This includes all subclasses
# of parameter including, but not limited to, regular parameters, metaparameters, relationship
# parameters, and properties.
eachparameter do |parameter|
parameter.post_compile if parameter.respond_to? :post_compile
end
# Make sure all of our relationships are valid. Again, must be done
# when the entire catalog is instantiated.
self.class.relationship_params.collect do |klass|
if param = @parameters[klass.name]
param.validate_relationship
end
end.flatten.reject { |r| r.nil? }
end | ruby | {
"resource": ""
} |
q10940 | Puppet::Environments.EnvironmentCreator.for | train | def for(module_path, manifest)
Puppet::Node::Environment.create(:anonymous,
module_path.split(File::PATH_SEPARATOR),
manifest)
end | ruby | {
"resource": ""
} |
q10941 | Puppet::Environments.Static.get_conf | train | def get_conf(name)
env = get(name)
if env
Puppet::Settings::EnvironmentConf.static_for(env, Puppet[:environment_timeout], Puppet[:static_catalogs], Puppet[:rich_data])
else
nil
end
end | ruby | {
"resource": ""
} |
q10942 | Puppet::Environments.Cached.add_entry | train | def add_entry(name, cache_entry)
Puppet.debug {"Caching environment '#{name}' #{cache_entry.label}"}
@cache[name] = cache_entry
expires = cache_entry.expires
@expirations.add(expires)
if @next_expiration > expires
@next_expiration = expires
end
end | ruby | {
"resource": ""
} |
q10943 | Puppet::Environments.Cached.clear_all_expired | train | def clear_all_expired()
t = Time.now
return if t < @next_expiration && ! @cache.any? {|name, _| @cache_expiration_service.expired?(name.to_sym) }
to_expire = @cache.select { |name, entry| entry.expires < t || @cache_expiration_service.expired?(name.to_sym) }
to_expire.each do |name, entry|
Puppet.debug {"Evicting cache entry for environment '#{name}'"}
@cache_expiration_service.evicted(name)
clear(name)
@expirations.delete(entry.expires)
Puppet.settings.clear_environment_settings(name)
end
@next_expiration = @expirations.first || END_OF_TIME
end | ruby | {
"resource": ""
} |
q10944 | Puppet::Environments.Cached.entry | train | def entry(env)
ttl = (conf = get_conf(env.name)) ? conf.environment_timeout : Puppet.settings.value(:environment_timeout)
case ttl
when 0
NotCachedEntry.new(env) # Entry that is always expired (avoids syscall to get time)
when Float::INFINITY
Entry.new(env) # Entry that never expires (avoids syscall to get time)
else
TTLEntry.new(env, ttl)
end
end | ruby | {
"resource": ""
} |
q10945 | Puppet::Environments.Cached.evict_if_expired | train | def evict_if_expired(name)
if (result = @cache[name]) && (result.expired? || @cache_expiration_service.expired?(name))
Puppet.debug {"Evicting cache entry for environment '#{name}'"}
@cache_expiration_service.evicted(name)
clear(name)
Puppet.settings.clear_environment_settings(name)
end
end | ruby | {
"resource": ""
} |
q10946 | Puppet::ModuleTool.Checksums.data | train | def data
unless @data
@data = {}
@path.find do |descendant|
if Puppet::ModuleTool.artifact?(descendant)
Find.prune
elsif descendant.file?
path = descendant.relative_path_from(@path)
@data[path.to_s] = checksum(descendant)
end
end
end
return @data
end | ruby | {
"resource": ""
} |
q10947 | Puppet::Rest.Route.with_base_url | train | def with_base_url(dns_resolver)
if @server && @port
# First try connecting to the previously selected server and port.
begin
return yield(base_url)
rescue SystemCallError => e
if Puppet[:use_srv_records]
Puppet.debug "Connection to cached server and port #{@server}:#{@port} failed, reselecting."
else
raise Puppet::Error, _("Connection to cached server and port %{server}:%{port} failed: %{message}") %
{ server: @server, port: @port, message: e.message }
end
end
end
if Puppet[:use_srv_records]
dns_resolver.each_srv_record(Puppet[:srv_domain], @srv_service) do |srv_server, srv_port|
# Try each of the servers for this service in weighted order
# until a working one is found.
begin
@server = srv_server
@port = srv_port
return yield(base_url)
rescue SystemCallError
Puppet.debug "Connection to selected server and port #{@server}:#{@port} failed. Trying next cached SRV record."
@server = nil
@port = nil
end
end
end
# If not using SRV records, fall back to the defaults calculated above
@server = @default_server
@port = @default_port
Puppet.debug "No more servers in SRV record, falling back to #{@server}:#{@port}" if Puppet[:use_srv_records]
return yield(base_url)
end | ruby | {
"resource": ""
} |
q10948 | Puppet.Application.run | train | def run
# I don't really like the names of these lifecycle phases. It would be nice to change them to some more meaningful
# names, and make deprecated aliases. --cprice 2012-03-16
exit_on_fail(_("Could not get application-specific default settings")) do
initialize_app_defaults
end
Puppet::ApplicationSupport.push_application_context(self.class.run_mode, self.class.get_environment_mode)
exit_on_fail(_("Could not initialize")) { preinit }
exit_on_fail(_("Could not parse application options")) { parse_options }
exit_on_fail(_("Could not prepare for execution")) { setup }
if deprecated?
Puppet.deprecation_warning(_("`puppet %{name}` is deprecated and will be removed in a future release.") % { name: name })
end
exit_on_fail(_("Could not configure routes from %{route_file}") % { route_file: Puppet[:route_file] }) { configure_indirector_routes }
exit_on_fail(_("Could not log runtime debug info")) { log_runtime_environment }
exit_on_fail(_("Could not run")) { run_command }
end | ruby | {
"resource": ""
} |
q10949 | Puppet.Application.log_runtime_environment | train | def log_runtime_environment(extra_info=nil)
runtime_info = {
'puppet_version' => Puppet.version,
'ruby_version' => RUBY_VERSION,
'run_mode' => self.class.run_mode.name,
}
runtime_info['default_encoding'] = Encoding.default_external
runtime_info.merge!(extra_info) unless extra_info.nil?
Puppet.debug 'Runtime environment: ' + runtime_info.map{|k,v| k + '=' + v.to_s}.join(', ')
end | ruby | {
"resource": ""
} |
q10950 | Puppet::Functions.DispatcherBuilder.required_repeated_param | train | def required_repeated_param(type, name)
internal_param(type, name, true)
raise ArgumentError, _('A required repeated parameter cannot be added after an optional parameter') if @min != @max
@min += 1
@max = :default
end | ruby | {
"resource": ""
} |
q10951 | Puppet::Functions.DispatcherBuilder.block_param | train | def block_param(*type_and_name)
case type_and_name.size
when 0
type = @all_callables
name = :block
when 1
type = @all_callables
name = type_and_name[0]
when 2
type, name = type_and_name
type = Puppet::Pops::Types::TypeParser.singleton.parse(type, loader) unless type.is_a?(Puppet::Pops::Types::PAnyType)
else
raise ArgumentError, _("block_param accepts max 2 arguments (type, name), got %{size}.") % { size: type_and_name.size }
end
unless Puppet::Pops::Types::TypeCalculator.is_kind_of_callable?(type, false)
raise ArgumentError, _("Expected PCallableType or PVariantType thereof, got %{type_class}") % { type_class: type.class }
end
unless name.is_a?(Symbol)
raise ArgumentError, _("Expected block_param name to be a Symbol, got %{name_class}") % { name_class: name.class }
end
if @block_type.nil?
@block_type = type
@block_name = name
else
raise ArgumentError, _('Attempt to redefine block')
end
end | ruby | {
"resource": ""
} |
q10952 | Puppet::Functions.LocalTypeAliasesBuilder.type | train | def type(assignment_string)
# Get location to use in case of error - this produces ruby filename and where call to 'type' occurred
# but strips off the rest of the internal "where" as it is not meaningful to user.
#
rb_location = caller[0]
begin
result = parser.parse_string("type #{assignment_string}", nil)
rescue StandardError => e
rb_location = rb_location.gsub(/:in.*$/, '')
# Create a meaningful location for parse errors - show both what went wrong with the parsing
# and in which ruby file it was found.
raise ArgumentError, _("Parsing of 'type \"%{assignment_string}\"' failed with message: <%{message}>.\n" +
"Called from <%{ruby_file_location}>") % {
assignment_string: assignment_string,
message: e.message,
ruby_file_location: rb_location
}
end
unless result.body.kind_of?(Puppet::Pops::Model::TypeAlias)
rb_location = rb_location.gsub(/:in.*$/, '')
raise ArgumentError, _("Expected a type alias assignment on the form 'AliasType = T', got '%{assignment_string}'.\n"+
"Called from <%{ruby_file_location}>") % {
assignment_string: assignment_string,
ruby_file_location: rb_location
}
end
@local_types << result.body
end | ruby | {
"resource": ""
} |
q10953 | Puppet::Pops.MergeStrategy.lookup | train | def lookup(lookup_variants, lookup_invocation)
case lookup_variants.size
when 0
throw :no_such_key
when 1
merge_single(yield(lookup_variants[0]))
else
lookup_invocation.with(:merge, self) do
result = lookup_variants.reduce(NOT_FOUND) do |memo, lookup_variant|
not_found = true
value = catch(:no_such_key) do
v = yield(lookup_variant)
not_found = false
v
end
if not_found
memo
else
memo.equal?(NOT_FOUND) ? convert_value(value) : merge(memo, value)
end
end
throw :no_such_key if result == NOT_FOUND
lookup_invocation.report_result(result)
end
end
end | ruby | {
"resource": ""
} |
q10954 | Puppet::Network::HTTP::Compression.Active.uncompress_body | train | def uncompress_body(response)
case response['content-encoding']
when 'gzip'
# ZLib::GzipReader has an associated encoding, by default Encoding.default_external
return Zlib::GzipReader.new(StringIO.new(response.body), :encoding => Encoding::BINARY).read
when 'deflate'
return Zlib::Inflate.new.inflate(response.body)
when nil, 'identity'
return response.body
else
raise Net::HTTPError.new(_("Unknown content encoding - %{encoding}") % { encoding: response['content-encoding'] }, response)
end
end | ruby | {
"resource": ""
} |
q10955 | Puppet::Network.Rights.newright | train | def newright(name, line=nil, file=nil)
add_right( Right.new(name, line, file) )
end | ruby | {
"resource": ""
} |
q10956 | Puppet.Network::AuthStore.allowed? | train | def allowed?(name, ip)
if name or ip
# This is probably unnecessary, and can cause some weirdness in
# cases where we're operating over localhost but don't have a real
# IP defined.
raise Puppet::DevError, _("Name and IP must be passed to 'allowed?'") unless name and ip
# else, we're networked and such
else
# we're local
return true
end
# yay insecure overrides
return true if globalallow?
if decl = declarations.find { |d| d.match?(name, ip) }
return decl.result
end
info _("defaulting to no access for %{name}") % { name: name }
false
end | ruby | {
"resource": ""
} |
q10957 | Puppet::MetaType.Manager.type | train | def type(name)
# Avoid loading if name obviously is not a type name
if name.to_s.include?(':')
return nil
end
@types ||= {}
# We are overwhelmingly symbols here, which usually match, so it is worth
# having this special-case to return quickly. Like, 25K symbols vs. 300
# strings in this method. --daniel 2012-07-17
return @types[name] if @types.include? name
# Try mangling the name, if it is a string.
if name.is_a? String
name = name.downcase.intern
return @types[name] if @types.include? name
end
# Try loading the type.
if typeloader.load(name, Puppet.lookup(:current_environment))
#TRANSLATORS 'puppet/type/%{name}' should not be translated
Puppet.warning(_("Loaded puppet/type/%{name} but no class was created") % { name: name }) unless @types.include? name
elsif !Puppet[:always_retry_plugins]
# PUP-5482 - Only look for a type once if plugin retry is disabled
@types[name] = nil
end
# ...and I guess that is that, eh.
return @types[name]
end | ruby | {
"resource": ""
} |
q10958 | Puppet::Pops.Loaders.[] | train | def [](loader_name)
loader = @loaders_by_name[loader_name]
if loader.nil?
# Unable to find the module private loader. Try resolving the module
loader = private_loader_for_module(loader_name[0..-9]) if loader_name.end_with?(' private')
raise Puppet::ParseError, _("Unable to find loader named '%{loader_name}'") % { loader_name: loader_name } if loader.nil?
end
loader
end | ruby | {
"resource": ""
} |
q10959 | Puppet::Pops.Loaders.find_loader | train | def find_loader(module_name)
if module_name.nil? || EMPTY_STRING == module_name
# Use the public environment loader
public_environment_loader
else
# TODO : Later check if definition is private, and then add it to private_loader_for_module
#
loader = public_loader_for_module(module_name)
if loader.nil?
raise Puppet::ParseError, _("Internal Error: did not find public loader for module: '%{module_name}'") % { module_name: module_name }
end
loader
end
end | ruby | {
"resource": ""
} |
q10960 | Puppet::Pops.Loaders.load_main_manifest | train | def load_main_manifest
parser = Parser::EvaluatingParser.singleton
parsed_code = Puppet[:code]
program = if parsed_code != ""
parser.parse_string(parsed_code, 'unknown-source-location')
else
file = @environment.manifest
# if the manifest file is a reference to a directory, parse and combine
# all .pp files in that directory
if file == Puppet::Node::Environment::NO_MANIFEST
nil
elsif File.directory?(file)
raise Puppet::Error, "manifest of environment '#{@environment.name}' appoints directory '#{file}'. It must be a file"
elsif File.exists?(file)
parser.parse_file(file)
else
raise Puppet::Error, "manifest of environment '#{@environment.name}' appoints '#{file}'. It does not exist"
end
end
instantiate_definitions(program, public_environment_loader) unless program.nil?
program
rescue Puppet::ParseErrorWithIssue => detail
detail.environment = @environment.name
raise
rescue => detail
msg = _('Could not parse for environment %{env}: %{detail}') % { env: @environment, detail: detail }
error = Puppet::Error.new(msg)
error.set_backtrace(detail.backtrace)
raise error
end | ruby | {
"resource": ""
} |
q10961 | Puppet::Pops.Loaders.instantiate_definitions | train | def instantiate_definitions(program, loader)
program.definitions.each { |d| instantiate_definition(d, loader) }
nil
end | ruby | {
"resource": ""
} |
q10962 | Puppet::Pops.Loaders.instantiate_definition | train | def instantiate_definition(definition, loader)
case definition
when Model::PlanDefinition
instantiate_PlanDefinition(definition, loader)
when Model::FunctionDefinition
instantiate_FunctionDefinition(definition, loader)
when Model::TypeAlias
instantiate_TypeAlias(definition, loader)
when Model::TypeMapping
instantiate_TypeMapping(definition, loader)
else
raise Puppet::ParseError, "Internal Error: Unknown type of definition - got '#{definition.class}'"
end
end | ruby | {
"resource": ""
} |
q10963 | Puppet::Util::IniConfig.Section.[]= | train | def []=(key, value)
entry = find_entry(key)
@dirty = true
if entry.nil?
@entries << [key, value]
else
entry[1] = value
end
end | ruby | {
"resource": ""
} |
q10964 | Puppet::Util::IniConfig.Section.format | train | def format
if @destroy
text = ""
else
text = "[#{name}]\n"
@entries.each do |entry|
if entry.is_a?(Array)
key, value = entry
text << "#{key}=#{value}\n" unless value.nil?
else
text << entry
end
end
end
text
end | ruby | {
"resource": ""
} |
q10965 | Puppet::Util::IniConfig.PhysicalFile.read | train | def read
text = @filetype.read
if text.nil?
raise IniParseError, _("Cannot read nonexistent file %{file}") % { file: @file.inspect }
end
parse(text)
end | ruby | {
"resource": ""
} |
q10966 | Puppet::Util::IniConfig.PhysicalFile.add_section | train | def add_section(name)
if section_exists?(name)
raise IniParseError.new(_("Section %{name} is already defined, cannot redefine") % { name: name.inspect }, @file)
end
section = Section.new(name, @file)
@contents << section
section
end | ruby | {
"resource": ""
} |
q10967 | Puppet.ExternalFileError.to_s | train | def to_s
msg = super
@file = nil if (@file.is_a?(String) && @file.empty?)
msg += Puppet::Util::Errors.error_location_with_space(@file, @line, @pos)
msg
end | ruby | {
"resource": ""
} |
q10968 | Puppet::Network::HTTP.Connection.handle_retry_after | train | def handle_retry_after(response)
retry_after = response['Retry-After']
return response if retry_after.nil?
retry_sleep = parse_retry_after_header(retry_after)
# Recover remote hostname if Net::HTTPResponse was generated by a
# method that fills in the uri attribute.
#
server_hostname = if response.uri.is_a?(URI)
response.uri.host
else
# TRANSLATORS: Used in the phrase:
# "Received a response from the remote server."
_('the remote server')
end
if retry_sleep.nil?
Puppet.err(_('Received a %{status_code} response from %{server_hostname}, but the Retry-After header value of "%{retry_after}" could not be converted to an integer or RFC 2822 date.') %
{status_code: response.code,
server_hostname: server_hostname,
retry_after: retry_after.inspect})
return response
end
# Cap maximum sleep at the run interval of the Puppet agent.
retry_sleep = [retry_sleep, Puppet[:runinterval]].min
Puppet.warning(_('Received a %{status_code} response from %{server_hostname}. Sleeping for %{retry_sleep} seconds before retrying the request.') %
{status_code: response.code,
server_hostname: server_hostname,
retry_sleep: retry_sleep})
::Kernel.sleep(retry_sleep)
return nil
end | ruby | {
"resource": ""
} |
q10969 | Puppet::Network::HTTP.Connection.parse_retry_after_header | train | def parse_retry_after_header(header_value)
retry_after = begin
Integer(header_value)
rescue TypeError, ArgumentError
begin
DateTime.rfc2822(header_value)
rescue ArgumentError
return nil
end
end
case retry_after
when Integer
retry_after
when DateTime
sleep = (retry_after.to_time - DateTime.now.to_time).to_i
(sleep > 0) ? sleep : 0
end
end | ruby | {
"resource": ""
} |
q10970 | Puppet::Util::Windows.Registry.values_by_name | train | def values_by_name(key, names)
vals = {}
names.each do |name|
FFI::Pointer.from_string_to_wide_string(name) do |subkeyname_ptr|
begin
_, vals[name] = read(key, subkeyname_ptr)
rescue Puppet::Util::Windows::Error => e
# ignore missing names, but raise other errors
raise e unless e.code == Puppet::Util::Windows::Error::ERROR_FILE_NOT_FOUND
end
end
end
vals
end | ruby | {
"resource": ""
} |
q10971 | Puppet::Util::FileParsing.FileRecord.fields= | train | def fields=(fields)
@fields = fields.collect do |field|
r = field.intern
raise ArgumentError.new(_("Cannot have fields named %{name}") % { name: r }) if INVALID_FIELDS.include?(r)
r
end
end | ruby | {
"resource": ""
} |
q10972 | Puppet::Util::FileParsing.FileRecord.join | train | def join(details)
joinchar = self.joiner
fields.collect { |field|
# If the field is marked absent, use the appropriate replacement
if details[field] == :absent or details[field] == [:absent] or details[field].nil?
if self.optional.include?(field)
self.absent
else
raise ArgumentError, _("Field '%{field}' is required") % { field: field }
end
else
details[field].to_s
end
}.reject { |c| c.nil?}.join(joinchar)
end | ruby | {
"resource": ""
} |
q10973 | Kafka.RoundRobinAssignmentStrategy.assign | train | def assign(members:, topics:)
group_assignment = {}
members.each do |member_id|
group_assignment[member_id] = Protocol::MemberAssignment.new
end
topic_partitions = topics.flat_map do |topic|
begin
partitions = @cluster.partitions_for(topic).map(&:partition_id)
rescue UnknownTopicOrPartition
raise UnknownTopicOrPartition, "unknown topic #{topic}"
end
Array.new(partitions.count) { topic }.zip(partitions)
end
partitions_per_member = topic_partitions.group_by.with_index do |_, index|
index % members.count
end.values
members.zip(partitions_per_member).each do |member_id, member_partitions|
unless member_partitions.nil?
member_partitions.each do |topic, partition|
group_assignment[member_id].assign(topic, [partition])
end
end
end
group_assignment
rescue Kafka::LeaderNotAvailable
sleep 1
retry
end | ruby | {
"resource": ""
} |
q10974 | Kafka.MessageBuffer.clear_messages | train | def clear_messages(topic:, partition:)
return unless @buffer.key?(topic) && @buffer[topic].key?(partition)
@size -= @buffer[topic][partition].count
@bytesize -= @buffer[topic][partition].map(&:bytesize).reduce(0, :+)
@buffer[topic].delete(partition)
@buffer.delete(topic) if @buffer[topic].empty?
end | ruby | {
"resource": ""
} |
q10975 | Kafka.Client.deliver_message | train | def deliver_message(value, key: nil, headers: {}, topic:, partition: nil, partition_key: nil, retries: 1)
create_time = Time.now
message = PendingMessage.new(
value: value,
key: key,
headers: headers,
topic: topic,
partition: partition,
partition_key: partition_key,
create_time: create_time
)
if partition.nil?
partition_count = @cluster.partitions_for(topic).count
partition = Partitioner.partition_for_key(partition_count, message)
end
buffer = MessageBuffer.new
buffer.write(
value: message.value,
key: message.key,
headers: message.headers,
topic: message.topic,
partition: partition,
create_time: message.create_time,
)
@cluster.add_target_topics([topic])
compressor = Compressor.new(
instrumenter: @instrumenter,
)
transaction_manager = TransactionManager.new(
cluster: @cluster,
logger: @logger,
idempotent: false,
transactional: false
)
operation = ProduceOperation.new(
cluster: @cluster,
transaction_manager: transaction_manager,
buffer: buffer,
required_acks: 1,
ack_timeout: 10,
compressor: compressor,
logger: @logger,
instrumenter: @instrumenter,
)
attempt = 1
begin
operation.execute
unless buffer.empty?
raise DeliveryFailed.new(nil, [message])
end
rescue Kafka::Error => e
@cluster.mark_as_stale!
if attempt >= (retries + 1)
raise
else
attempt += 1
@logger.warn "Error while delivering message, #{e.class}: #{e.message}; retrying after 1s..."
sleep 1
retry
end
end
end | ruby | {
"resource": ""
} |
q10976 | Kafka.Client.producer | train | def producer(
compression_codec: nil,
compression_threshold: 1,
ack_timeout: 5,
required_acks: :all,
max_retries: 2,
retry_backoff: 1,
max_buffer_size: 1000,
max_buffer_bytesize: 10_000_000,
idempotent: false,
transactional: false,
transactional_id: nil,
transactional_timeout: 60
)
cluster = initialize_cluster
compressor = Compressor.new(
codec_name: compression_codec,
threshold: compression_threshold,
instrumenter: @instrumenter,
)
transaction_manager = TransactionManager.new(
cluster: cluster,
logger: @logger,
idempotent: idempotent,
transactional: transactional,
transactional_id: transactional_id,
transactional_timeout: transactional_timeout,
)
Producer.new(
cluster: cluster,
transaction_manager: transaction_manager,
logger: @logger,
instrumenter: @instrumenter,
compressor: compressor,
ack_timeout: ack_timeout,
required_acks: required_acks,
max_retries: max_retries,
retry_backoff: retry_backoff,
max_buffer_size: max_buffer_size,
max_buffer_bytesize: max_buffer_bytesize,
)
end | ruby | {
"resource": ""
} |
q10977 | Kafka.Client.async_producer | train | def async_producer(delivery_interval: 0, delivery_threshold: 0, max_queue_size: 1000, max_retries: -1, retry_backoff: 0, **options)
sync_producer = producer(**options)
AsyncProducer.new(
sync_producer: sync_producer,
delivery_interval: delivery_interval,
delivery_threshold: delivery_threshold,
max_queue_size: max_queue_size,
max_retries: max_retries,
retry_backoff: retry_backoff,
instrumenter: @instrumenter,
logger: @logger,
)
end | ruby | {
"resource": ""
} |
q10978 | Kafka.Client.consumer | train | def consumer(
group_id:,
session_timeout: 30,
offset_commit_interval: 10,
offset_commit_threshold: 0,
heartbeat_interval: 10,
offset_retention_time: nil,
fetcher_max_queue_size: 100
)
cluster = initialize_cluster
instrumenter = DecoratingInstrumenter.new(@instrumenter, {
group_id: group_id,
})
# The Kafka protocol expects the retention time to be in ms.
retention_time = (offset_retention_time && offset_retention_time * 1_000) || -1
group = ConsumerGroup.new(
cluster: cluster,
logger: @logger,
group_id: group_id,
session_timeout: session_timeout,
retention_time: retention_time,
instrumenter: instrumenter,
)
fetcher = Fetcher.new(
cluster: initialize_cluster,
group: group,
logger: @logger,
instrumenter: instrumenter,
max_queue_size: fetcher_max_queue_size
)
offset_manager = OffsetManager.new(
cluster: cluster,
group: group,
fetcher: fetcher,
logger: @logger,
commit_interval: offset_commit_interval,
commit_threshold: offset_commit_threshold,
offset_retention_time: offset_retention_time
)
heartbeat = Heartbeat.new(
group: group,
interval: heartbeat_interval,
instrumenter: instrumenter
)
Consumer.new(
cluster: cluster,
logger: @logger,
instrumenter: instrumenter,
group: group,
offset_manager: offset_manager,
fetcher: fetcher,
session_timeout: session_timeout,
heartbeat: heartbeat,
)
end | ruby | {
"resource": ""
} |
q10979 | Kafka.Client.fetch_messages | train | def fetch_messages(topic:, partition:, offset: :latest, max_wait_time: 5, min_bytes: 1, max_bytes: 1048576, retries: 1)
operation = FetchOperation.new(
cluster: @cluster,
logger: @logger,
min_bytes: min_bytes,
max_bytes: max_bytes,
max_wait_time: max_wait_time,
)
operation.fetch_from_partition(topic, partition, offset: offset, max_bytes: max_bytes)
attempt = 1
begin
operation.execute.flat_map {|batch| batch.messages }
rescue Kafka::Error => e
@cluster.mark_as_stale!
if attempt >= (retries + 1)
raise
else
attempt += 1
@logger.warn "Error while fetching messages, #{e.class}: #{e.message}; retrying..."
retry
end
end
end | ruby | {
"resource": ""
} |
q10980 | Kafka.Client.each_message | train | def each_message(topic:, start_from_beginning: true, max_wait_time: 5, min_bytes: 1, max_bytes: 1048576, &block)
default_offset ||= start_from_beginning ? :earliest : :latest
offsets = Hash.new { default_offset }
loop do
operation = FetchOperation.new(
cluster: @cluster,
logger: @logger,
min_bytes: min_bytes,
max_wait_time: max_wait_time,
)
@cluster.partitions_for(topic).map(&:partition_id).each do |partition|
partition_offset = offsets[partition]
operation.fetch_from_partition(topic, partition, offset: partition_offset, max_bytes: max_bytes)
end
batches = operation.execute
batches.each do |batch|
batch.messages.each(&block)
offsets[batch.partition] = batch.last_offset + 1 unless batch.unknown_last_offset?
end
end
end | ruby | {
"resource": ""
} |
q10981 | Kafka.Client.create_topic | train | def create_topic(name, num_partitions: 1, replication_factor: 1, timeout: 30, config: {})
@cluster.create_topic(
name,
num_partitions: num_partitions,
replication_factor: replication_factor,
timeout: timeout,
config: config,
)
end | ruby | {
"resource": ""
} |
q10982 | Kafka.Client.create_partitions_for | train | def create_partitions_for(name, num_partitions: 1, timeout: 30)
@cluster.create_partitions_for(name, num_partitions: num_partitions, timeout: timeout)
end | ruby | {
"resource": ""
} |
q10983 | Kafka.Client.last_offsets_for | train | def last_offsets_for(*topics)
@cluster.add_target_topics(topics)
topics.map {|topic|
partition_ids = @cluster.partitions_for(topic).collect(&:partition_id)
partition_offsets = @cluster.resolve_offsets(topic, partition_ids, :latest)
[topic, partition_offsets.collect { |k, v| [k, v - 1] }.to_h]
}.to_h
end | ruby | {
"resource": ""
} |
q10984 | Kafka.Cluster.add_target_topics | train | def add_target_topics(topics)
topics = Set.new(topics)
unless topics.subset?(@target_topics)
new_topics = topics - @target_topics
unless new_topics.empty?
@logger.info "New topics added to target list: #{new_topics.to_a.join(', ')}"
@target_topics.merge(new_topics)
refresh_metadata!
end
end
end | ruby | {
"resource": ""
} |
q10985 | Kafka.Cluster.get_transaction_coordinator | train | def get_transaction_coordinator(transactional_id:)
@logger.debug "Getting transaction coordinator for `#{transactional_id}`"
refresh_metadata_if_necessary!
if transactional_id.nil?
# Get a random_broker
@logger.debug "Transaction ID is not available. Choose a random broker."
return random_broker
else
get_coordinator(Kafka::Protocol::COORDINATOR_TYPE_TRANSACTION, transactional_id)
end
end | ruby | {
"resource": ""
} |
q10986 | Kafka.Cluster.list_topics | train | def list_topics
response = random_broker.fetch_metadata(topics: nil)
response.topics.select do |topic|
topic.topic_error_code == 0
end.map(&:topic_name)
end | ruby | {
"resource": ""
} |
q10987 | Kafka.Cluster.fetch_cluster_info | train | def fetch_cluster_info
errors = []
@seed_brokers.shuffle.each do |node|
@logger.info "Fetching cluster metadata from #{node}"
begin
broker = @broker_pool.connect(node.hostname, node.port)
cluster_info = broker.fetch_metadata(topics: @target_topics)
if cluster_info.brokers.empty?
@logger.error "No brokers in cluster"
else
@logger.info "Discovered cluster metadata; nodes: #{cluster_info.brokers.join(', ')}"
@stale = false
return cluster_info
end
rescue Error => e
@logger.error "Failed to fetch metadata from #{node}: #{e}"
errors << [node, e]
ensure
broker.disconnect unless broker.nil?
end
end
error_description = errors.map {|node, exception| "- #{node}: #{exception}" }.join("\n")
raise ConnectionError, "Could not connect to any of the seed brokers:\n#{error_description}"
end | ruby | {
"resource": ""
} |
q10988 | Kafka.AsyncProducer.produce | train | def produce(value, topic:, **options)
ensure_threads_running!
if @queue.size >= @max_queue_size
buffer_overflow topic,
"Cannot produce to #{topic}, max queue size (#{@max_queue_size} messages) reached"
end
args = [value, **options.merge(topic: topic)]
@queue << [:produce, args]
@instrumenter.instrument("enqueue_message.async_producer", {
topic: topic,
queue_size: @queue.size,
max_queue_size: @max_queue_size,
})
nil
end | ruby | {
"resource": ""
} |
q10989 | Kafka.SSLSocketWithTimeout.write | train | def write(bytes)
loop do
written = 0
begin
# unlike plain tcp sockets, ssl sockets don't support IO.select
# properly.
# Instead, timeouts happen on a per write basis, and we have to
# catch exceptions from write_nonblock, and gradually build up
# our write buffer.
written += @ssl_socket.write_nonblock(bytes)
rescue Errno::EFAULT => error
raise error
rescue OpenSSL::SSL::SSLError, Errno::EAGAIN, Errno::EWOULDBLOCK, IO::WaitWritable => error
if error.is_a?(OpenSSL::SSL::SSLError) && error.message == 'write would block'
if select_with_timeout(@ssl_socket, :write)
retry
else
raise Errno::ETIMEDOUT
end
else
raise error
end
end
# Fast, common case.
break if written == bytes.size
# This takes advantage of the fact that most ruby implementations
# have Copy-On-Write strings. Thusly why requesting a subrange
# of data, we actually don't copy data because the new string
# simply references a subrange of the original.
bytes = bytes[written, bytes.size]
end
end | ruby | {
"resource": ""
} |
q10990 | Kafka.Consumer.subscribe | train | def subscribe(topic_or_regex, default_offset: nil, start_from_beginning: true, max_bytes_per_partition: 1048576)
default_offset ||= start_from_beginning ? :earliest : :latest
if topic_or_regex.is_a?(Regexp)
cluster_topics.select { |topic| topic =~ topic_or_regex }.each do |topic|
subscribe_to_topic(topic, default_offset, start_from_beginning, max_bytes_per_partition)
end
else
subscribe_to_topic(topic_or_regex, default_offset, start_from_beginning, max_bytes_per_partition)
end
nil
end | ruby | {
"resource": ""
} |
q10991 | Kafka.Consumer.pause | train | def pause(topic, partition, timeout: nil, max_timeout: nil, exponential_backoff: false)
if max_timeout && !exponential_backoff
raise ArgumentError, "`max_timeout` only makes sense when `exponential_backoff` is enabled"
end
pause_for(topic, partition).pause!(
timeout: timeout,
max_timeout: max_timeout,
exponential_backoff: exponential_backoff,
)
end | ruby | {
"resource": ""
} |
q10992 | Kafka.Consumer.resume | train | def resume(topic, partition)
pause_for(topic, partition).resume!
# During re-balancing we might have lost the paused partition. Check if partition is still in group before seek.
seek_to_next(topic, partition) if @group.assigned_to?(topic, partition)
end | ruby | {
"resource": ""
} |
q10993 | Kafka.Consumer.paused? | train | def paused?(topic, partition)
pause = pause_for(topic, partition)
pause.paused? && !pause.expired?
end | ruby | {
"resource": ""
} |
q10994 | Kafka.OffsetManager.seek_to_default | train | def seek_to_default(topic, partition)
# Remove any cached offset, in case things have changed broker-side.
clear_resolved_offset(topic)
offset = resolve_offset(topic, partition)
seek_to(topic, partition, offset)
end | ruby | {
"resource": ""
} |
q10995 | Kafka.OffsetManager.seek_to | train | def seek_to(topic, partition, offset)
@processed_offsets[topic] ||= {}
@processed_offsets[topic][partition] = offset
@fetcher.seek(topic, partition, offset)
end | ruby | {
"resource": ""
} |
q10996 | Kafka.OffsetManager.next_offset_for | train | def next_offset_for(topic, partition)
offset = @processed_offsets.fetch(topic, {}).fetch(partition) {
committed_offset_for(topic, partition)
}
# A negative offset means that no offset has been committed, so we need to
# resolve the default offset for the topic.
if offset < 0
resolve_offset(topic, partition)
else
# The next offset is the last offset.
offset
end
end | ruby | {
"resource": ""
} |
q10997 | Kafka.OffsetManager.commit_offsets | train | def commit_offsets(recommit = false)
offsets = offsets_to_commit(recommit)
unless offsets.empty?
@logger.debug "Committing offsets#{recommit ? ' with recommit' : ''}: #{prettify_offsets(offsets)}"
@group.commit_offsets(offsets)
@last_commit = Time.now
@last_recommit = Time.now if recommit
@uncommitted_offsets = 0
@committed_offsets = nil
end
end | ruby | {
"resource": ""
} |
q10998 | Kafka.OffsetManager.clear_offsets_excluding | train | def clear_offsets_excluding(excluded)
# Clear all offsets that aren't in `excluded`.
@processed_offsets.each do |topic, partitions|
partitions.keep_if do |partition, _|
excluded.fetch(topic, []).include?(partition)
end
end
# Clear the cached commits from the brokers.
@committed_offsets = nil
@resolved_offsets.clear
end | ruby | {
"resource": ""
} |
q10999 | Kafka.Connection.send_request | train | def send_request(request)
api_name = Protocol.api_name(request.api_key)
# Default notification payload.
notification = {
broker_host: @host,
api: api_name,
request_size: 0,
response_size: 0,
}
raise IdleConnection if idle?
@logger.push_tags(api_name)
@instrumenter.instrument("request.connection", notification) do
open unless open?
@correlation_id += 1
@logger.debug "Sending #{api_name} API request #{@correlation_id} to #{to_s}"
write_request(request, notification)
response_class = request.response_class
response = wait_for_response(response_class, notification) unless response_class.nil?
@last_request = Time.now
response
end
rescue SystemCallError, EOFError, IOError => e
close
raise ConnectionError, "Connection error #{e.class}: #{e}"
ensure
@logger.pop_tags
end | ruby | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.