_id stringlengths 2 6 | title stringlengths 9 130 | partition stringclasses 3 values | text stringlengths 66 10.5k | language stringclasses 1 value | meta_information dict |
|---|---|---|---|---|---|
q20700 | Amistad.ActiveRecordFriendshipModel.can_block? | train | def can_block?(friendable)
active? && (approved? || (pending? && self.friend_id == friendable.id && friendable.class.to_s == Amistad.friend_model))
end | ruby | {
"resource": ""
} |
q20701 | Amistad.ActiveRecordFriendshipModel.can_unblock? | train | def can_unblock?(friendable)
blocked? && self.blocker_id == friendable.id && friendable.class.to_s == Amistad.friend_model
end | ruby | {
"resource": ""
} |
q20702 | TileUp.TileUpLogger.add | train | def add(severity, message)
severity = TileUpLogger.sym_to_severity(severity)
logger.add(severity, message)
end | ruby | {
"resource": ""
} |
q20703 | Bosh::Cli.Config.deployment | train | def deployment
return nil if target.nil?
if @config_file.has_key?("deployment")
if is_old_deployment_config?
set_deployment(@config_file["deployment"])
save
end
if @config_file["deployment"].is_a?(Hash)
return @config_file["deployment"][target]
end
end
end | ruby | {
"resource": ""
} |
q20704 | Resourceful.Builder.apply | train | def apply
apply_publish
kontroller = @controller
Resourceful::ACTIONS.each do |action_named|
# See if this is a method listed by #actions
unless @ok_actions.include? action_named
# If its not listed, then remove the method
# No one can hit it... if its DEAD!
@action_module.send :remove_method, action_named
end
end
kontroller.hidden_actions.reject! &@ok_actions.method(:include?)
kontroller.send :include, @action_module
merged_callbacks = kontroller.resourceful_callbacks.merge @callbacks
merged_responses = kontroller.resourceful_responses.merge @responses
kontroller.resourceful_callbacks = merged_callbacks
kontroller.resourceful_responses = merged_responses
kontroller.made_resourceful = true
kontroller.parents = @parents
kontroller.shallow_parent = @shallow_parent
kontroller.model_namespace = @model_namespace
kontroller.before_filter :load_object, :only => (@ok_actions & SINGULAR_PRELOADED_ACTIONS) + @custom_member_actions
kontroller.before_filter :load_objects, :only => (@ok_actions & PLURAL_ACTIONS) + @custom_collection_actions
kontroller.before_filter :load_parent_object, :only => @ok_actions + @custom_member_actions + @custom_collection_actions
end | ruby | {
"resource": ""
} |
q20705 | Resourceful.Builder.belongs_to | train | def belongs_to(*parents)
options = parents.extract_options!
@parents = parents.map(&:to_s)
if options[:shallow]
options[:shallow] = options[:shallow].to_s
raise ArgumentError, ":shallow needs the name of a parent resource" unless @parents.include? options[:shallow]
@shallow_parent = options[:shallow]
end
end | ruby | {
"resource": ""
} |
q20706 | Amistad.MongoFriendModel.blocked? | train | def blocked?(user)
(blocked_friend_ids + blocked_inverse_friend_ids + blocked_pending_inverse_friend_ids).include?(user.id) or user.blocked_pending_inverse_friend_ids.include?(self.id)
end | ruby | {
"resource": ""
} |
q20707 | Amistad.MongoFriendModel.friendshiped_with? | train | def friendshiped_with?(user)
(friend_ids + inverse_friend_ids + pending_friend_ids + pending_inverse_friend_ids + blocked_friend_ids).include?(user.id)
end | ruby | {
"resource": ""
} |
q20708 | Amistad.MongoFriendModel.delete_all_friendships | train | def delete_all_friendships
friend_ids.clear
inverse_friend_ids.clear
pending_friend_ids.clear
pending_inverse_friend_ids.clear
blocked_friend_ids.clear
blocked_inverse_friend_ids.clear
blocked_pending_friend_ids.clear
blocked_pending_inverse_friend_ids.clear
self.save
end | ruby | {
"resource": ""
} |
q20709 | RailsMocks.ControllerMethods.render | train | def render(options=nil, deprecated_status_or_extra_options=nil, &block)
if ::Rails::VERSION::STRING >= '2.0.0' && deprecated_status_or_extra_options.nil?
deprecated_status_or_extra_options = {}
end
unless block_given?
if @template.respond_to?(:finder)
(class << @template.finder; self; end).class_eval do
define_method :file_exists? do; true; end
end
else
(class << @template; self; end).class_eval do
define_method :file_exists? do; true; end
end
end
(class << @template; self; end).class_eval do
define_method :render_file do |*args|
@first_render ||= args[0] unless args[0] =~ /^layouts/
@_first_render ||= args[0] unless args[0] =~ /^layouts/
end
define_method :_pick_template do |*args|
@_first_render ||= args[0] unless args[0] =~ /^layouts/
PickedTemplate.new
end
end
end
super(options, deprecated_status_or_extra_options, &block)
end | ruby | {
"resource": ""
} |
q20710 | Amistad.ActiveRecordFriendModel.unblock | train | def unblock(user)
friendship = find_any_friendship_with(user)
return false if friendship.nil? || !friendship.can_unblock?(self)
friendship.update_attribute(:blocker, nil)
end | ruby | {
"resource": ""
} |
q20711 | Amistad.ActiveRecordFriendModel.find_any_friendship_with | train | def find_any_friendship_with(user)
friendship = Amistad.friendship_class.where(:friendable_id => self.id, :friend_id => user.id).first
if friendship.nil?
friendship = Amistad.friendship_class.where(:friendable_id => user.id, :friend_id => self.id).first
end
friendship
end | ruby | {
"resource": ""
} |
q20712 | Tripod::Extensions.Module.re_define_method | train | def re_define_method(name, &block)
undef_method(name) if method_defined?(name)
define_method(name, &block)
end | ruby | {
"resource": ""
} |
q20713 | Tripod::RdfType.ClassMethods.rdf_type | train | def rdf_type(new_rdf_type)
self._RDF_TYPE = RDF::URI.new(new_rdf_type.to_s)
field :rdf_type, RDF.type, :multivalued => true, :is_uri => true # things can have more than 1 type and often do
end | ruby | {
"resource": ""
} |
q20714 | Xi.Pattern.p | train | def p(*delta, **metadata)
delta = delta.compact.empty? ? @delta : delta
Pattern.new(@source, delta: delta, size: @size, **@metadata.merge(metadata))
end | ruby | {
"resource": ""
} |
q20715 | Xi.Pattern.each_event | train | def each_event(cycle=0)
return enum_for(__method__, cycle) unless block_given?
EventEnumerator.new(self, cycle).each { |v, s, d, i| yield v, s, d, i }
end | ruby | {
"resource": ""
} |
q20716 | Xi.Pattern.each_delta | train | def each_delta(index=0)
return enum_for(__method__, index) unless block_given?
delta = @delta
if delta.is_a?(Array)
size = delta.size
return if size == 0
start = index.floor
i = start % size
loop do
yield delta[i]
i = (i + 1) % size
start += 1
end
elsif delta.is_a?(Pattern)
delta.each_event(index) { |v, _| yield v }
else
loop { yield delta }
end
end | ruby | {
"resource": ""
} |
q20717 | Xi.Pattern.each | train | def each
return enum_for(__method__) unless block_given?
each_event { |v, _, _, i|
break if i > 0
yield v
}
end | ruby | {
"resource": ""
} |
q20718 | Xi.Pattern.select | train | def select
return enum_for(__method__) unless block_given?
Pattern.new(self) do |y, d|
each_event do |v, s, ed, i|
y << v if yield(v, s, ed, i)
end
end
end | ruby | {
"resource": ""
} |
q20719 | Xi.Pattern.reject | train | def reject
return enum_for(__method__) unless block_given?
select { |v, s, d, i| !yield(v, s, d, i) }
end | ruby | {
"resource": ""
} |
q20720 | Xi.Pattern.first | train | def first(n=nil, *args)
res = take(n || 1, *args)
n.nil? ? res.first : res
end | ruby | {
"resource": ""
} |
q20721 | Xi.Pattern.inspect | train | def inspect
ss = if @source.respond_to?(:join)
@source.map(&:inspect).join(', ')
elsif @source.is_a?(Proc)
"?proc"
else
@source.inspect
end
ms = @metadata.reject { |_, v| v.nil? }
ms.merge!(delta: delta) if delta != 1
ms = ms.map { |k, v| "#{k}: #{v.inspect}" }.join(', ')
"P[#{ss}#{", #{ms}" unless ms.empty?}]"
end | ruby | {
"resource": ""
} |
q20722 | Tripod::Fields.ClassMethods.get_field | train | def get_field(name)
@fields ||= {}
field = fields[name]
raise Tripod::Errors::FieldNotPresent.new unless field
field
end | ruby | {
"resource": ""
} |
q20723 | Tripod::Fields.ClassMethods.fields | train | def fields
tripod_superclasses.map { |c| c.instance_variable_get(:@fields) }.reduce do |acc,class_fields|
class_fields.merge(acc)
end
end | ruby | {
"resource": ""
} |
q20724 | Tripod::Fields.ClassMethods.add_field | train | def add_field(name, predicate, options = {})
# create a field object and store it in our hash
field = field_for(name, predicate, options)
@fields ||= {}
@fields[name] = field
# set up the accessors for the fields
create_accessors(name, name, options)
# create a URL validation if appropriate
# (format nabbed from https://gist.github.com/joshuap/948880)
validates(name, is_url: true) if field.is_uri?
field
end | ruby | {
"resource": ""
} |
q20725 | Tripod::Fields.ClassMethods.create_accessors | train | def create_accessors(name, meth, options = {})
field = @fields[name]
create_field_getter(name, meth, field)
create_field_setter(name, meth, field)
create_field_check(name, meth, field)
# from dirty.rb
create_dirty_methods(name, meth)
end | ruby | {
"resource": ""
} |
q20726 | Tripod::Fields.ClassMethods.create_field_getter | train | def create_field_getter(name, meth, field)
generated_methods.module_eval do
re_define_method(meth) do
read_attribute(name, field)
end
end
end | ruby | {
"resource": ""
} |
q20727 | Tripod::Fields.ClassMethods.create_field_setter | train | def create_field_setter(name, meth, field)
generated_methods.module_eval do
re_define_method("#{meth}=") do |value|
write_attribute(name, value, field)
end
end
end | ruby | {
"resource": ""
} |
q20728 | Tripod::Fields.ClassMethods.create_field_check | train | def create_field_check(name, meth, field)
generated_methods.module_eval do
re_define_method("#{meth}?") do
attr = read_attribute(name, field)
attr == true || attr.present?
end
end
end | ruby | {
"resource": ""
} |
q20729 | Tripod::Fields.ClassMethods.field_for | train | def field_for(name, predicate, options)
Tripod::Fields::Standard.new(name, predicate, options)
end | ruby | {
"resource": ""
} |
q20730 | Tripod::Finders.ClassMethods.describe_uris | train | def describe_uris(uris)
graph = RDF::Graph.new
if uris.length > 0
uris_sparql_str = uris.map{ |u| "<#{u.to_s}>" }.join(" ")
# Do a big describe statement, and read the results into an in-memory repo
ntriples_string = Tripod::SparqlClient::Query.query("CONSTRUCT { ?s ?p ?o } WHERE { VALUES ?s { #{uris_sparql_str} }. ?s ?p ?o . }", Tripod.ntriples_header_str)
graph = _rdf_graph_from_ntriples_string(ntriples_string, graph)
end
graph
end | ruby | {
"resource": ""
} |
q20731 | Tripod::Finders.ClassMethods._rdf_graph_from_ntriples_string | train | def _rdf_graph_from_ntriples_string(ntriples_string, graph=nil)
graph ||= RDF::Graph.new
RDF::Reader.for(:ntriples).new(ntriples_string) do |reader|
reader.each_statement do |statement|
graph << statement
end
end
graph
end | ruby | {
"resource": ""
} |
q20732 | Tripod::Finders.ClassMethods._graph_of_triples_from_construct_or_describe | train | def _graph_of_triples_from_construct_or_describe(construct_query)
ntriples_str = Tripod::SparqlClient::Query.query(construct_query, Tripod.ntriples_header_str)
_rdf_graph_from_ntriples_string(ntriples_str, graph=nil)
end | ruby | {
"resource": ""
} |
q20733 | Tripod::Finders.ClassMethods._create_and_hydrate_resources_from_sparql | train | def _create_and_hydrate_resources_from_sparql(select_sparql, opts={})
# TODO: Optimization?: if return_graph option is false, then don't do this next line?
uris_and_graphs = _select_uris_and_graphs(select_sparql, :uri_variable => opts[:uri_variable], :graph_variable => opts[:graph_variable])
#there are no resources if there are no uris and graphs
if uris_and_graphs.empty?
[]
else
construct_query = _construct_query_for_uris_and_graphs(uris_and_graphs)
graph = _graph_of_triples_from_construct_or_describe(construct_query)
_resources_from_graph(graph, uris_and_graphs)
end
end | ruby | {
"resource": ""
} |
q20734 | Tripod::Finders.ClassMethods._construct_query_for_uris_and_graphs | train | def _construct_query_for_uris_and_graphs(uris_and_graphs)
value_pairs = uris_and_graphs.map do |(uri, graph)|
u = RDF::URI.new(uri).to_base
g = graph ? RDF::URI.new(graph).to_base : 'UNDEF'
"(#{u} #{g})"
end
query = "CONSTRUCT { ?uri ?p ?o . #{ self.all_triples_construct("?uri") }} WHERE { GRAPH ?g { ?uri ?p ?o . #{ self.all_triples_where("?uri") } VALUES (?uri ?g) { #{ value_pairs.join(' ') } } } }"
end | ruby | {
"resource": ""
} |
q20735 | Tripod::Finders.ClassMethods._raw_describe_select_results | train | def _raw_describe_select_results(select_sparql, opts={})
accept_header = opts[:accept_header] || Tripod.ntriples_header_str
query = _describe_query_for_select(select_sparql, :uri_variable => opts[:uri_variable])
Tripod::SparqlClient::Query.query(query, accept_header)
end | ruby | {
"resource": ""
} |
q20736 | Tripod.ResourceCollection.to_nt | train | def to_nt
time_serialization('nt') do
if @criteria
@criteria.serialize(:return_graph => @return_graph, :accept_header => Tripod.ntriples_header_str)
elsif @sparql_query_str && @resource_class
# run the query as a describe.
@resource_class._raw_describe_select_results(@sparql_query_str, :accept_header => Tripod.ntriples_header_str)
else
# for n-triples we can just concatenate them
nt = ""
resources.each do |resource|
nt += resource.to_nt
end
nt
end
end
end | ruby | {
"resource": ""
} |
q20737 | Tripod.CriteriaExecution.resources | train | def resources(opts={})
Tripod::ResourceCollection.new(
self.resource_class._resources_from_sparql(self.as_query(opts)),
# pass in the criteria that was used to generate this collection, as well as whether the user specified return graph
:return_graph => (opts.has_key?(:return_graph) ? opts[:return_graph] : true),
:criteria => self
)
end | ruby | {
"resource": ""
} |
q20738 | Tripod.CriteriaExecution.first | train | def first(opts={})
sq = Tripod::SparqlQuery.new(self.as_query(opts))
first_sparql = sq.as_first_query_str
self.resource_class._resources_from_sparql(first_sparql).first
end | ruby | {
"resource": ""
} |
q20739 | Tripod.CriteriaExecution.count | train | def count(opts={})
sq = Tripod::SparqlQuery.new(self.as_query(opts))
count_sparql = sq.as_count_query_str
result = Tripod::SparqlClient::Query.select(count_sparql)
if result.length > 0
result[0]["tripod_count_var"]["value"].to_i
else
return 0
end
end | ruby | {
"resource": ""
} |
q20740 | Tripod.CriteriaExecution.as_query | train | def as_query(opts={})
Tripod.logger.debug("TRIPOD: building select query for criteria...")
return_graph = opts.has_key?(:return_graph) ? opts[:return_graph] : true
Tripod.logger.debug("TRIPOD: with return_graph: #{return_graph.inspect}")
select_query = "SELECT DISTINCT ?uri "
if graph_lambdas.empty?
if return_graph
# if we are returning the graph, select it as a variable, and include either the <graph> or ?graph in the where clause
if graph_uri
select_query += "(<#{graph_uri}> as ?graph) WHERE { GRAPH <#{graph_uri}> { "
else
select_query += "?graph WHERE { GRAPH ?graph { "
end
else
select_query += "WHERE { "
# if we're not returning the graph, only restrict by the <graph> if there's one set at class level
select_query += "GRAPH <#{graph_uri}> { " if graph_uri
end
select_query += self.query_where_clauses.join(" . ")
select_query += " } "
select_query += "} " if return_graph || graph_uri # close the graph clause
else
# whip through the graph lambdas and add into the query
# we have multiple graphs so the above does not apply
select_query += "WHERE { "
graph_lambdas.each do |lambda_item|
select_query += "GRAPH ?g { "
select_query += lambda_item.call
select_query += " } "
end
select_query += self.query_where_clauses.join(" . ")
select_query += " } "
end
select_query += self.extra_clauses.join(" ")
select_query += [order_clause, limit_clause, offset_clause].join(" ")
select_query.strip
end | ruby | {
"resource": ""
} |
q20741 | Tripod::Repository.ClassMethods.add_data_to_repository | train | def add_data_to_repository(graph, repo=nil)
repo ||= RDF::Repository.new()
graph.each_statement do |statement|
repo << statement
end
repo
end | ruby | {
"resource": ""
} |
q20742 | Tripod.Criteria.graph | train | def graph(graph_uri, &block)
if block_given?
self.graph_lambdas ||= []
self.graph_lambdas << block
self
else
self.graph_uri = graph_uri.to_s
self
end
end | ruby | {
"resource": ""
} |
q20743 | Tripod::Links.ClassMethods.linked_from_for | train | def linked_from_for(name, incoming_field_name, options)
Tripod::Links::LinkedFrom.new(name, incoming_field_name, options)
end | ruby | {
"resource": ""
} |
q20744 | Tripod::Links.ClassMethods.linked_to_for | train | def linked_to_for(name, predicate, options)
Tripod::Links::LinkedTo.new(name, predicate, options)
end | ruby | {
"resource": ""
} |
q20745 | StoryBranch.Main.validate_branch_name | train | def validate_branch_name(name, id)
if GitUtils.branch_for_story_exists? id
prompt.error("An existing branch has the same story id: #{id}")
return false
end
if GitUtils.existing_branch? name
prompt.error('This name is very similar to an existing branch. Avoid confusion and use a more unique name.')
return false
end
true
end | ruby | {
"resource": ""
} |
q20746 | Akephalos.Node.value | train | def value
case tag_name
when "select"
if self[:multiple]
selected_options.map { |option| option.value }
else
selected_option = @_node.selected_options.first
selected_option ? Node.new(selected_option).value : nil
end
when "option"
self[:value] || text
when "textarea"
@_node.getText
else
self[:value]
end
end | ruby | {
"resource": ""
} |
q20747 | Akephalos.Node.value= | train | def value=(value)
case tag_name
when "textarea"
@_node.setText("")
type(value)
when "input"
if file_input?
@_node.setValueAttribute(value)
else
@_node.setValueAttribute("")
type(value)
end
end
end | ruby | {
"resource": ""
} |
q20748 | Akephalos.Node.click | train | def click
@_node.click
@_node.getPage.getEnclosingWindow.getJobManager.waitForJobs(1000)
@_node.getPage.getEnclosingWindow.getJobManager.waitForJobsStartingBefore(1000)
end | ruby | {
"resource": ""
} |
q20749 | Mtdevise.AccountsController.create | train | def create
account = if user_signed_in?
Mtdevise::Account.create(account_params)
else
Mtdevise::Account.create_with_owner(account_params)
end
@account = account
if account.valid?
flash[:success] = "Your account has been successfully created."
if user_signed_in?
account.owner = current_user
account.users << current_user
account.save
redirect_to mtdevise.accounts_path
else
sign_in account.owner
redirect_to mtdevise.root_url(:subdomain => account.subdomain)
end
else
flash[:error] = "Sorry, your account could not be created."
render :new
end
end | ruby | {
"resource": ""
} |
q20750 | Hpe3parSdk.Client.get_ws_api_version | train | def get_ws_api_version
# remove everything down to host:port
host_url = @api_url.split('/api')
@http.set_url(host_url[0])
begin
# get the api version
response = @http.get('/api')
response[1]
rescue => ex
Util.log_exception(ex, caller_locations(1, 1)[0].label)
raise ex
end
ensure
# reset the url
@http.set_url(@api_url)
end | ruby | {
"resource": ""
} |
q20751 | Hpe3parSdk.Client.create_flash_cache | train | def create_flash_cache(size_in_gib, mode = nil)
begin
@flash_cache.create_flash_cache(size_in_gib, mode)
rescue => ex
Util.log_exception(ex, caller_locations(1, 1)[0].label)
raise ex
end
end | ruby | {
"resource": ""
} |
q20752 | Hpe3parSdk.Client.get_flash_cache | train | def get_flash_cache
begin
@flash_cache.get_flash_cache
rescue => ex
Util.log_exception(ex, caller_locations(1, 1)[0].label)
raise ex
end
end | ruby | {
"resource": ""
} |
q20753 | Hpe3parSdk.Client.delete_flash_cache | train | def delete_flash_cache
begin
@flash_cache.delete_flash_cache
rescue => ex
Util.log_exception(ex, caller_locations(1, 1)[0].label)
raise ex
end
end | ruby | {
"resource": ""
} |
q20754 | Hpe3parSdk.Client.get_overall_system_capacity | train | def get_overall_system_capacity
begin
response = @http.get('/capacity')
response[1]
rescue => ex
Util.log_exception(ex, caller_locations(1, 1)[0].label)
raise ex
end
end | ruby | {
"resource": ""
} |
q20755 | Hpe3parSdk.Client.get_all_tasks | train | def get_all_tasks
begin
@task.get_all_tasks
rescue => ex
Util.log_exception(ex, caller_locations(1, 1)[0].label)
raise ex
end
end | ruby | {
"resource": ""
} |
q20756 | Hpe3parSdk.Client.get_task | train | def get_task(task_id)
begin
@task.get_task(task_id)
rescue => ex
Util.log_exception(ex, caller_locations(1, 1)[0].label)
raise ex
end
end | ruby | {
"resource": ""
} |
q20757 | Hpe3parSdk.Client.create_vlun | train | def create_vlun(volume_name, lun = nil, host_name = nil, port_pos = nil, no_vcn = false, override_lower_priority = false, auto = false)
begin
@vlun.create_vlun(volume_name, host_name, lun, port_pos, no_vcn, override_lower_priority, auto)
rescue => ex
Util.log_exception(ex, caller_locations(1, 1)[0].label)
raise ex
end
end | ruby | {
"resource": ""
} |
q20758 | Hpe3parSdk.Client.get_vluns | train | def get_vluns
begin
@vlun.get_vluns
rescue => ex
Util.log_exception(ex, caller_locations(1, 1)[0].label)
raise ex
end
end | ruby | {
"resource": ""
} |
q20759 | Hpe3parSdk.Client.get_vlun | train | def get_vlun(volume_name)
begin
@vlun.get_vlun(volume_name)
rescue => ex
Util.log_exception(ex, caller_locations(1, 1)[0].label)
raise ex
end
end | ruby | {
"resource": ""
} |
q20760 | Hpe3parSdk.Client.delete_vlun | train | def delete_vlun(volume_name, lun_id, host_name = nil, port = nil)
begin
@vlun.delete_vlun(volume_name, lun_id, host_name, port)
rescue => ex
Util.log_exception(ex, caller_locations(1, 1)[0].label)
raise ex
end
end | ruby | {
"resource": ""
} |
q20761 | Hpe3parSdk.Client.query_qos_rules | train | def query_qos_rules
begin
@qos.query_qos_rules
rescue => ex
Util.log_exception(ex, caller_locations(1, 1)[0].label)
raise ex
end
end | ruby | {
"resource": ""
} |
q20762 | Hpe3parSdk.Client.query_qos_rule | train | def query_qos_rule(target_name, target_type = 'vvset')
begin
@qos.query_qos_rule(target_name, target_type)
rescue => ex
Util.log_exception(ex, caller_locations(1, 1)[0].label)
raise ex
end
end | ruby | {
"resource": ""
} |
q20763 | Hpe3parSdk.Client.modify_qos_rules | train | def modify_qos_rules(target_name, qos_rules, target_type = QoStargetTypeConstants::VVSET)
if @current_version < @min_version && !qos_rules.nil?
qos_rules.delete_if { |key, _value| key == :latencyGoaluSecs }
end
begin
@qos.modify_qos_rules(target_name, qos_rules, target_type)
rescue => ex
Util.log_exception(ex, caller_locations(1, 1)[0].label)
raise ex
end
end | ruby | {
"resource": ""
} |
q20764 | Hpe3parSdk.Client.delete_qos_rules | train | def delete_qos_rules(target_name, target_type = QoStargetTypeConstants::VVSET)
begin
@qos.delete_qos_rules(target_name, target_type)
rescue => ex
Util.log_exception(ex, caller_locations(1, 1)[0].label)
raise ex
end
end | ruby | {
"resource": ""
} |
q20765 | Hpe3parSdk.Client.get_hosts | train | def get_hosts
begin
@host.get_hosts
rescue => ex
Util.log_exception(ex, caller_locations(1, 1)[0].label)
raise ex
end
end | ruby | {
"resource": ""
} |
q20766 | Hpe3parSdk.Client.get_host | train | def get_host(name)
begin
@host.get_host(name)
rescue => ex
Util.log_exception(ex, caller_locations(1, 1)[0].label)
raise ex
end
end | ruby | {
"resource": ""
} |
q20767 | Hpe3parSdk.Client.create_host | train | def create_host(name, iscsi_names = nil, fcwwns = nil, optional = nil)
begin
@host.create_host(name, iscsi_names, fcwwns, optional)
rescue => ex
Util.log_exception(ex, caller_locations(1, 1)[0].label)
raise ex
end
end | ruby | {
"resource": ""
} |
q20768 | Hpe3parSdk.Client.modify_host | train | def modify_host(name, mod_request)
begin
@host.modify_host(name, mod_request)
rescue => ex
Util.log_exception(ex, caller_locations(1, 1)[0].label)
raise ex
end
end | ruby | {
"resource": ""
} |
q20769 | Hpe3parSdk.Client.delete_host | train | def delete_host(name)
begin
@host.delete_host(name)
rescue => ex
Util.log_exception(ex, caller_locations(1, 1)[0].label)
raise ex
end
end | ruby | {
"resource": ""
} |
q20770 | Hpe3parSdk.Client.query_host_by_fc_path | train | def query_host_by_fc_path(wwn = nil)
begin
@host.query_host_by_fc_path(wwn)
rescue => ex
Util.log_exception(ex, caller_locations(1, 1)[0].label)
raise ex
end
end | ruby | {
"resource": ""
} |
q20771 | Hpe3parSdk.Client.query_host_by_iscsi_path | train | def query_host_by_iscsi_path(iqn = nil)
begin
@host.query_host_by_iscsi_path(iqn)
rescue => ex
Util.log_exception(ex, caller_locations(1, 1)[0].label)
raise ex
end
end | ruby | {
"resource": ""
} |
q20772 | Hpe3parSdk.Client.get_host_sets | train | def get_host_sets
begin
@host_set.get_host_sets
rescue => ex
Util.log_exception(ex, caller_locations(1, 1)[0].label)
raise ex
end
end | ruby | {
"resource": ""
} |
q20773 | Hpe3parSdk.Client.delete_host_set | train | def delete_host_set(name)
begin
@host_set.delete_host_set(name)
rescue => ex
Util.log_exception(ex, caller_locations(1, 1)[0].label)
raise ex
end
end | ruby | {
"resource": ""
} |
q20774 | Hpe3parSdk.Client.modify_host_set | train | def modify_host_set(name, action = nil, setmembers = nil, new_name = nil, comment = nil)
begin
@host_set.modify_host_set(name, action, setmembers, new_name, comment)
rescue => ex
Util.log_exception(ex, caller_locations(1, 1)[0].label)
raise ex
end
end | ruby | {
"resource": ""
} |
q20775 | Hpe3parSdk.Client.find_host_sets | train | def find_host_sets(host_name)
begin
@host_set.find_host_sets(host_name)
rescue => ex
Util.log_exception(ex, caller_locations(1, 1)[0].label)
raise ex
end
end | ruby | {
"resource": ""
} |
q20776 | Hpe3parSdk.Client.get_host_set | train | def get_host_set(name)
begin
@host_set.get_host_set(name)
rescue => ex
Util.log_exception(ex, caller_locations(1, 1)[0].label)
raise ex
end
end | ruby | {
"resource": ""
} |
q20777 | Hpe3parSdk.Client.get_host_vluns | train | def get_host_vluns(host_name)
begin
@host.get_host_vluns(host_name)
rescue => ex
Util.log_exception(ex, caller_locations(1, 1)[0].label)
raise ex
end
end | ruby | {
"resource": ""
} |
q20778 | Hpe3parSdk.Client.get_volumes | train | def get_volumes
begin
@volume.get_volumes(VolumeCopyType::BASE_VOLUME)
rescue => ex
Util.log_exception(ex, caller_locations(1, 1)[0].label)
raise ex
end
end | ruby | {
"resource": ""
} |
q20779 | Hpe3parSdk.Client.get_snapshots | train | def get_snapshots
begin
@volume.get_volumes(VolumeCopyType::VIRTUAL_COPY)
rescue => ex
Util.log_exception(ex, caller_locations(1, 1)[0].label)
raise ex
end
end | ruby | {
"resource": ""
} |
q20780 | Hpe3parSdk.Client.get_volume | train | def get_volume(name)
begin
@volume.get_volume(name)
rescue => ex
Util.log_exception(ex, caller_locations(1, 1)[0].label)
raise ex
end
end | ruby | {
"resource": ""
} |
q20781 | Hpe3parSdk.Client.get_volume_by_wwn | train | def get_volume_by_wwn(wwn)
begin
@volume.get_volume_by_wwn(wwn)
rescue => ex
Util.log_exception(ex, caller_locations(1, 1)[0].label)
raise ex
end
end | ruby | {
"resource": ""
} |
q20782 | Hpe3parSdk.Client.create_volume | train | def create_volume(name, cpg_name, size_MiB, optional = nil)
if @current_version < @min_version_with_compression && !optional.nil?
optional.delete_if { |key, _value| key == :compression }
end
begin
@volume.create_volume(name, cpg_name, size_MiB, optional)
rescue => ex
Util.log_exception(ex, caller_locations(1, 1)[0].label)
raise ex
end
end | ruby | {
"resource": ""
} |
q20783 | Hpe3parSdk.Client.modify_volume | train | def modify_volume(name, volume_mods)
begin
@volume.modify_volume(name, volume_mods)
rescue => ex
Util.log_exception(ex, caller_locations(1, 1)[0].label)
raise ex
end
end | ruby | {
"resource": ""
} |
q20784 | Hpe3parSdk.Client.grow_volume | train | def grow_volume(name, amount)
begin
@volume.grow_volume(name, amount)
rescue => ex
Util.log_exception(ex, caller_locations(1, 1)[0].label)
raise ex
end
end | ruby | {
"resource": ""
} |
q20785 | Hpe3parSdk.Client.create_physical_copy | train | def create_physical_copy(src_name, dest_name, dest_cpg, optional = nil)
if @current_version < @min_version_with_compression && !optional.nil?
[:compression, :allowRemoteCopyParent, :skipZero].each { |key| optional.delete key }
end
begin
@volume.create_physical_copy(src_name, dest_name, dest_cpg, optional)
rescue => ex
Util.log_exception(ex, caller_locations(1, 1)[0].label)
raise ex
end
end | ruby | {
"resource": ""
} |
q20786 | Hpe3parSdk.Client.delete_physical_copy | train | def delete_physical_copy(name)
begin
@volume.delete_volume(name)
rescue => ex
Util.log_exception(ex, caller_locations(1, 1)[0].label)
raise ex
end
end | ruby | {
"resource": ""
} |
q20787 | Hpe3parSdk.Client.tune_volume | train | def tune_volume(name, tune_operation, optional = nil)
if @current_version < @min_version_with_compression && !optional.nil?
optional.delete_if { |key, _value| key == :compression }
end
begin
object_hash = @volume.tune_volume(name, tune_operation, optional)
get_task(object_hash['taskid'])
rescue => ex
Util.log_exception(ex, caller_locations(1, 1)[0].label)
raise ex
end
end | ruby | {
"resource": ""
} |
q20788 | Hpe3parSdk.Client.find_all_volume_sets | train | def find_all_volume_sets(name)
begin
@volume_set.find_all_volume_sets(name)
rescue => ex
Util.log_exception(ex, caller_locations(1, 1)[0].label)
raise ex
end
end | ruby | {
"resource": ""
} |
q20789 | Hpe3parSdk.Client.get_volume_sets | train | def get_volume_sets
begin
@volume_set.get_volume_sets
rescue => ex
Util.log_exception(ex, caller_locations(1, 1)[0].label)
raise ex
end
end | ruby | {
"resource": ""
} |
q20790 | Hpe3parSdk.Client.get_volume_set | train | def get_volume_set(name)
begin
@volume_set.get_volume_set(name)
rescue => ex
Util.log_exception(ex, caller_locations(1, 1)[0].label)
raise ex
end
end | ruby | {
"resource": ""
} |
q20791 | Hpe3parSdk.Client.create_volume_set | train | def create_volume_set(name, domain = nil, comment = nil, setmembers = nil)
begin
@volume_set.create_volume_set(name, domain, comment, setmembers)
rescue => ex
Util.log_exception(ex, caller_locations(1, 1)[0].label)
raise ex
end
end | ruby | {
"resource": ""
} |
q20792 | Hpe3parSdk.Client.delete_volume_set | train | def delete_volume_set(name)
begin
@volume_set.delete_volume_set(name)
rescue => ex
Util.log_exception(ex, caller_locations(1, 1)[0].label)
raise ex
end
end | ruby | {
"resource": ""
} |
q20793 | Hpe3parSdk.Client.modify_volume_set | train | def modify_volume_set(name, action = nil, newName = nil, comment = nil, flash_cache_policy = nil, setmembers = nil)
begin
@volume_set.modify_volume_set(name, action, newName, comment, flash_cache_policy, setmembers)
rescue => ex
Util.log_exception(ex, caller_locations(1, 1)[0].label)
raise ex
end
end | ruby | {
"resource": ""
} |
q20794 | Hpe3parSdk.Client.create_snapshot_of_volume_set | train | def create_snapshot_of_volume_set(name, copy_of_name, optional = nil)
begin
@volume_set.create_snapshot_of_volume_set(name, copy_of_name, optional)
rescue => ex
Util.log_exception(ex, caller_locations(1, 1)[0].label)
raise ex
end
end | ruby | {
"resource": ""
} |
q20795 | Hpe3parSdk.Client.create_snapshot | train | def create_snapshot(name, copy_of_name, optional = nil)
if @current_version < @min_version_with_compression && !optional.nil?
optional.delete_if { |key, _value| key == :allowRemoteCopyParent }
end
begin
@volume.create_snapshot(name, copy_of_name, optional)
rescue => ex
Util.log_exception(ex, caller_locations(1, 1)[0].label)
raise ex
end
end | ruby | {
"resource": ""
} |
q20796 | Hpe3parSdk.Client.get_volume_snapshots | train | def get_volume_snapshots(name)
begin
@volume.get_volume_snapshots(name)
rescue => ex
Util.log_exception(ex, caller_locations(1, 1)[0].label)
raise ex
end
end | ruby | {
"resource": ""
} |
q20797 | Hpe3parSdk.Client.get_ports | train | def get_ports
begin
@port.get_ports
rescue => ex
Util.log_exception(ex, caller_locations(1, 1)[0].label)
raise ex
end
end | ruby | {
"resource": ""
} |
q20798 | Hpe3parSdk.Client.get_fc_ports | train | def get_fc_ports(state = nil)
begin
@port.get_fc_ports(state)
rescue => ex
Util.log_exception(ex, caller_locations(1, 1)[0].label)
raise ex
end
end | ruby | {
"resource": ""
} |
q20799 | Hpe3parSdk.Client.get_iscsi_ports | train | def get_iscsi_ports(state = nil)
begin
@port.get_iscsi_ports(state)
rescue => ex
Util.log_exception(ex, caller_locations(1, 1)[0].label)
raise ex
end
end | ruby | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.