@!group Actions
 @example Request syntax with placeholder values

   load_balancer.attach()
 @param [Hash] options ({})
 @return [Types::AttachLoadBalancersResultType]
545881
def attach(options = {})
      options = Aws::Util.deep_merge(options,
        auto_scaling_group_name: @group_name,
        load_balancer_names: [@name]
      )
      resp = @client.attach_load_balancers(options)
      resp.data
    end
497546
def mount_reaction_defaults(opts)
      defaults = {
        at: '/reaction',
        server: 'thin',
        key: Rails.application.config.secret_token
      }
      opts = defaults.merge opts
    end
1216594
function (loadBalancer, callback) {
    var self = this,
        loadBalancerId =
          loadBalancer instanceof lb.LoadBalancer ? loadBalancer.id : loadBalancer;

    self._request({
      path: urlJoin(_urlPrefix, loadBalancerId, 'nodes', 'events')
    }, function (err, body) {
      return err
        ? callback(err)
        : callback(err, body.nodeServiceEvents);
    });
  }
393739
function attachActionsToTransport(transportObj, _actions) {
    let actionList = (typeof _actions === 'object' ? _actions : this[actions]);
    Object.keys(actionList).forEach((name) => {
      let actionObj = this[actions][name] && this[actions][name].action;
      if (actionObj) {
        let opt = this[actions][name].opt;
        if (opt.transport && opt.transport !== transportObj.name) return;
      }
      let k = transportObj._id + ':' + actionObj._id;
      if (typeof this[tracking][k] !== 'undefined') return;
      transportObj.routeAction(actionObj);
      this[tracking][k] = true;
    });
    for (let i = 0; i < unsavedActions.length; i++) {
      let item = unsavedActions[i];
      if (item.opt.transport && item.opt.transport !== transportObj.name) continue;
      let k = transportObj._id + ':' + item.action._id;
      if (typeof this[tracking][k] !== 'undefined') continue;
      transportObj.routeAction(item.action);
      this[tracking][k] = true;
    }
  }
1293410
def parse_options(options)
      @zk, @zkservers = options.values_at(:zk, :zkservers)
      if [@zk, @zkservers].all? || [@zk, @zkservers].none?
        raise ArgumentError, 'must specify :zk or :zkservers'
      end

      @root_znode = options.fetch(:znode_path, Util::DEFAULT_ROOT_ZNODE_PATH)
      @namespace = options[:namespace]
      @password = options[:password]
      @db = options[:db]
      @retry = options.fetch(:retry_failure, true)
      @max_retries = @retry ? options.fetch(:max_retries, 3) : 0
      @safe_mode = options.fetch(:safe_mode, true)
      @master_only = options.fetch(:master_only, false)
      @verify_role = options.fetch(:verify_role, true)

      @redis_client_options = Redis::Client::DEFAULTS.keys.each_with_object({}) do |key, hash| 
        hash[key] = options[key]
      end
    end
1182290
function (options, mCb) {
		getElbMethod(options.params.elbType || 'classic', 'delete', (elbResponse) => {
			const aws = options.infra.api;
			const elb = getConnector({
				api: elbResponse.api,
				region: options.params.region,
				keyId: aws.keyId,
				secretAccessKey: aws.secretAccessKey
			});
			let params = {
				LoadBalancerName: options.params.name
			};
			options.soajs.log.debug(params);
			elb[elbResponse.method](params, mCb);
		});
	}
181727
private boolean isAddToLoadBalancerSuspended(AutoScalingGroup asg) {
        List<SuspendedProcess> suspendedProcesses = asg.getSuspendedProcesses();
        for (SuspendedProcess process : suspendedProcesses) {
            if (PROP_ADD_TO_LOAD_BALANCER.equals(process.getProcessName())) {
                return true;
            }
        }
        return false;
    }
825087
function(options) {
            return {
              compose: app.composeCore,
              project: app.name,
              opts: {
                mode: 'attach',
                services: [options.service],
                entrypoint: options.entrypoint,
                cmd: options.cmd,
                app: app
              }
            };
          }
28900
def update_with(&blk)
      self.class.options.each do |name, config|
        value = yield(config)
        @values[name] = value unless value.nil?
      end
    end
1294272
def add_lb_nodes(self, lb_id, nodes):
        
        log.info("Adding load balancer nodes %s" % nodes)
        resp, body = self._request(
                'post', 
                '/loadbalancers/%s/nodes' % lb_id,
                data={'nodes': nodes})
        return body
22747
function(all) {
      var tasks = all? ['load-api']:['pack-prepare','load-api'];
      ss.bundler.forEach(function(bundler){
        if (all) {
          tasks.push(bundler.client.name + ':pack');
        } else if (bundler.packNeeded) {
          tasks.push(bundler.client.name + ':pack-needed');
          tasks.push(bundler.client.name + ':pack');
        } else {
          tasks.push(bundler.client.name + ':pack-unneeded');
        }
      });
      return tasks;
    }
1114364
def each(options = {}, &block)
      method = options[:reverse] ? :reverse_each : :each
      @set.sort_by(&:weight).send(method) do |item|
        if item.is_a?(ActiveScaffold::DataStructures::ActionLinks) && !options[:groups]
          item.each(options, &block)
        elsif options[:include_set]
          yield item, @set
        else
          yield item
        end
      end
    end
307797
def normalize_options(options)
      case options
      when Hash
        Hash[options.map{|k,v| [k.respond_to?(:to_sym) ? k.to_sym : k, v]}].tap do |opts|
          opts[:driver] = opts[:driver].to_s if opts[:driver]
        end
      when String, URI
        parse_connection_uri(options)
      else
        raise RDO::Exception,
          "Unsupported connection argument format: #{options.class.name}"
      end
    end
463270
def options=(options)
      if options
        options.each_pair do |option, value|
          Validators::Option.validate(option)
          send("#{option}=", value)
        end
      end
    end
584817
def load_api_provider_extensions!
      if config.get(:credentials, :provider)
        base_ext = Bogo::Utility.camel(config.get(:credentials, :provider)).to_sym
        targ_ext = self.class.name.split("::").last
        if ApiProvider.constants.include?(base_ext)
          base_module = ApiProvider.const_get(base_ext)
          ui.debug "Loading core provider extensions via `#{base_module}`"
          extend base_module
          if base_module.constants.include?(targ_ext)
            targ_module = base_module.const_get(targ_ext)
            ui.debug "Loading targeted provider extensions via `#{targ_module}`"
            extend targ_module
          end
          true
        end
      end
    end
603606
def add_to_group(connection, group_id)
      params = to_json_for_add
      url    = "/api/2.0/asset_groups/#{group_id}/tags"
      uri    = AJAX.post(connection, url, params, AJAX::CONTENT_TYPE::JSON)
      @id    = uri.split('/').last.to_i
    end
297238
def attach(ary, options = {})
      attachments = ary.is_a?(Array) ? ary : [ ary ] #force first arg to array
      post({ attachments: attachments }.merge(options))
    end