Gets the SAS Logical JBODs API client.

        Returns:
            SasLogicalJbod:
167231
def sas_logical_jbods(self):
        
        if not self.__sas_logical_jbods:
            self.__sas_logical_jbods = SasLogicalJbods(self.__connection)
        return self.__sas_logical_jbods
462020
@SuppressWarnings("unused")
    private static MBeanServerConnection getServerConnection(int pid) {

        try {
            JMXServiceURL serviceURL = new JMXServiceURL(connectorAddress(pid));
            return JMXConnectorFactory.connect(serviceURL).getMBeanServerConnection();
        } catch (MalformedURLException ex) {
            throw failed("JMX connection failed", ex);
        } catch (IOException ex) {
            throw failed("JMX connection failed", ex);
        }

    }
812036
public boolean getXmlStandalone() {
	// dynamic load to support jre 1.4 and 1.5
	try {
	    Method m = doc.getClass().getMethod("getXmlStandalone", new Class[] {});
	    return Caster.toBooleanValue(m.invoke(doc, ArrayUtil.OBJECT_EMPTY));
	}
	catch (Exception e) {
	    throw new PageRuntimeException(Caster.toPageException(e));
	}
    }
589766
def getrawblob(self, project_id, sha1):
        
        request = requests.get(
            '{0}/{1}/repository/raw_blobs/{2}'.format(self.projects_url, project_id, sha1),
            verify=self.verify_ssl, auth=self.auth, headers=self.headers, timeout=self.timeout)

        if request.status_code == 200:
            return request.content
        else:
            return False
1353142
public static HiveSerDeWrapper get(String serDeType) {
    return get(serDeType, Optional.<String> absent(), Optional.<String> absent());
  }
414239
public static JaxWsClientMetaData getJaxWsClientMetaData() {
        ModuleMetaData mmd = getModuleMetaData();
        //146981
        if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
            Tr.debug(tc, "mmd: " + mmd);
        return getJaxWsClientMetaData(mmd);

    }
1162465
def _get_block_blob_service(kwargs=None):
    '''
    
    '''
    resource_group = kwargs.get('resource_group') or config.get_cloud_config_value(
                         'resource_group',
                         get_configured_provider(), __opts__, search_global=False
                     )
    sas_token = kwargs.get('sas_token') or config.get_cloud_config_value(
                    'sas_token',
                    get_configured_provider(), __opts__, search_global=False
                )
    storage_account = kwargs.get('storage_account') or config.get_cloud_config_value(
                          'storage_account',
                          get_configured_provider(), __opts__, search_global=False
                      )
    storage_key = kwargs.get('storage_key') or config.get_cloud_config_value(
                      'storage_key',
                      get_configured_provider(), __opts__, search_global=False
                  )

    if not resource_group:
        raise SaltCloudSystemExit(
            'A resource group must be specified'
        )

    if not storage_account:
        raise SaltCloudSystemExit(
            'A storage account must be specified'
        )

    if not storage_key:
        storconn = get_conn(client_type='storage')
        storage_keys = storconn.storage_accounts.list_keys(resource_group, storage_account)
        storage_keys = {v.key_name: v.value for v in storage_keys.keys}
        storage_key = next(six.itervalues(storage_keys))

    cloud_env = _get_cloud_environment()

    endpoint_suffix = cloud_env.suffixes.storage_endpoint

    return BlockBlobService(storage_account, storage_key,
                            sas_token=sas_token,
                            endpoint_suffix=endpoint_suffix)
282797
protected boolean getBoolean()
  {                                                     
    if (tc.isEntryEnabled()) Tr.entry(tc, "getBoolean", this);

    byte dataByte = _buffer.get();
    boolean data = (dataByte == TRUE);

    if (tc.isEntryEnabled()) Tr.exit(tc, "getBoolean", new Boolean(data));
    return data;
  }
212752
def sas_logical_interconnects(self):
        
        if not self.__sas_logical_interconnects:
            self.__sas_logical_interconnects = SasLogicalInterconnects(self.__connection)
        return self.__sas_logical_interconnects
203913
def _to_java(self):
        

        sc = SparkContext._active_spark_context
        # TODO: persst validation metrics as well
        _java_obj = JavaParams._new_java_obj(
            "org.apache.spark.ml.tuning.TrainValidationSplitModel",
            self.uid,
            self.bestModel._to_java(),
            _py2java(sc, []))
        estimator, epms, evaluator = super(TrainValidationSplitModel, self)._to_java_impl()

        _java_obj.set("evaluator", evaluator)
        _java_obj.set("estimator", estimator)
        _java_obj.set("estimatorParamMaps", epms)

        if self.subModels is not None:
            java_sub_models = [sub_model._to_java() for sub_model in self.subModels]
            _java_obj.setSubModels(java_sub_models)

        return _java_obj
121700
public static MBeanServer getJolokiaMBeanServer() {
        MBeanServer server = ManagementFactory.getPlatformMBeanServer();
        MBeanServer jolokiaMBeanServer;
        try {
            jolokiaMBeanServer =
                    (MBeanServer) server.getAttribute(createObjectName(JolokiaMBeanServerHolderMBean.OBJECT_NAME),
                                                      JOLOKIA_MBEAN_SERVER_ATTRIBUTE);
        } catch (InstanceNotFoundException exp) {
            // should be probably locked, but for simplicity reasons and because
            // the probability of a clash is fairly low (can happen only once), it's omitted
            // here. Note, that server.getAttribute() itself is threadsafe.
            jolokiaMBeanServer = registerJolokiaMBeanServerHolderMBean(server);
        } catch (JMException e) {
            throw new IllegalStateException("Internal: Cannot get JolokiaMBean server via JMX lookup: " + e,e);
        }
        return jolokiaMBeanServer;
    }
658815
@Override
  public OperationHandle getSchemas(SessionHandle sessionHandle,
      String catalogName, String schemaName)
          throws HiveSQLException {
    OperationHandle opHandle = sessionManager.getSession(sessionHandle)
        .getSchemas(catalogName, schemaName);
    LOG.debug(sessionHandle + ": getSchemas()");
    return opHandle;
  }
161914
public static String getJavaClassFromSchemaInfo(String schemaInfo) {
        final String ONLY_JAVA_CLIENTS_SUPPORTED = "Only Java clients are supported currently, so the format of the schema-info should be: <schema-info>java=foo.Bar</schema-info> where foo.Bar is the fully qualified name of the message.";

        if(StringUtils.isEmpty(schemaInfo))
            throw new IllegalArgumentException("This serializer requires a non-empty schema-info.");

        String[] languagePairs = StringUtils.split(schemaInfo, ',');
        if(languagePairs.length > 1)
            throw new IllegalArgumentException(ONLY_JAVA_CLIENTS_SUPPORTED);

        String[] javaPair = StringUtils.split(languagePairs[0], '=');
        if(javaPair.length != 2 || !javaPair[0].trim().equals("java"))
            throw new IllegalArgumentException(ONLY_JAVA_CLIENTS_SUPPORTED);

        return javaPair[1].trim();
    }
1279033
def get_service(service_symbol, options, unwrap_bool)
		    raise "No SOAP client instantiated" unless @client

			request_options = build_request(options)

			raise "No SourceCredentials supplied" if !@src_creds || !request_options[SRC_CREDS] #Just checking for :source_credentials does not 
			#check all possiblities as "SourceCredentials", 
			response = @client.request Mb::Meta::NS, service_symbol do
				soap.body = 
				{	
					"Request" => request_options
				}
		    end	
			if unwrap_bool
				#Unwrap response to hash array underneath)
			    plural = service_symbol.to_s.gsub("get_", "")
				singular =plural[0..-2] #Remove last
			   	r = response.to_hash
				basify = lambda {|enda| (service_symbol.to_s + "_" + enda).to_sym }  
				r = r[basify.call('response')][basify.call('result')]
				return [] if r[:result_count] == "0"
				r = r[plural.to_sym][singular.to_sym]

				return r	 
			end
			
			response
		end
150572
private ManagedBeanInvocation getServiceInvocation(Message message, JmxEndpointConfiguration endpointConfiguration) {
        Object payload = message.getPayload();

        ManagedBeanInvocation serviceInvocation = null;
        if (payload != null) {
            if (payload instanceof ManagedBeanInvocation) {
                serviceInvocation = (ManagedBeanInvocation) payload;
            } else if (payload != null && StringUtils.hasText(message.getPayload(String.class))) {
                serviceInvocation = (ManagedBeanInvocation) endpointConfiguration.getMarshaller()
                        .unmarshal(message.getPayload(Source.class));
            } else {
                serviceInvocation = new ManagedBeanInvocation();
            }
        }

        return serviceInvocation;
    }
319980
static AbstractBeanDefinition findServerForSpecialEnvironment() {
        boolean weblogicPresent = ClassUtils.isPresent("weblogic.management.Helper",
                ServletContextAwareMBeanServerDefinitionParser.class.getClassLoader());

        boolean webspherePresent = ClassUtils.isPresent("com.ibm.websphere.management.AdminServiceFactory",
                ServletContextAwareMBeanServerDefinitionParser.class.getClassLoader());

        if (weblogicPresent) {
            RootBeanDefinition bd = new RootBeanDefinition(JndiObjectFactoryBean.class);
            bd.getPropertyValues().add("jndiName", "java:comp/env/jmx/runtime");
            return bd;
        } else if (webspherePresent) {
            return new RootBeanDefinition(WebSphereMBeanServerFactoryBean.class);
        } else {
            return null;
        }
    }
138557
def get_abbr_impl(env):
    """"""
    impl = env.python_implementation

    if impl == "PyPy":
        return "pp"
    elif impl == "Jython":
        return "jy"
    elif impl == "IronPython":
        return "ip"
    elif impl == "CPython":
        return "cp"

    raise LookupError("Unknown Python implementation: " + impl)