Get detail of stream in the live stream service.

@param domain The requested domain which the specific stream belongs to
@param app The requested app which the specific stream belongs to
@param stream The requested stream to pause
@return the response
334648
public PauseDomainStreamResponse pauseDomainStream(String domain, String app, String stream) {
        PauseDomainStreamRequest request = new PauseDomainStreamRequest();
        request.withDomain(domain).withApp(app).withStream(stream);
        return pauseDomainStream(request);
    }
1191586
public PauseAppStreamResponse pauseAppStream(String app, String stream) {
        PauseAppStreamRequest pauseAppStreamRequest = new PauseAppStreamRequest();
        pauseAppStreamRequest.setApp(app);
        pauseAppStreamRequest.setStream(stream);
        return pauseAppStream(pauseAppStreamRequest);
    }
752017
public static dnstxtrec get(nitro_service service, String domain) throws Exception{
		dnstxtrec obj = new dnstxtrec();
		obj.set_domain(domain);
		dnstxtrec response = (dnstxtrec) obj.get_resource(service);
		return response;
	}
1338909
public GetStreamResponse getStream(GetStreamRequest request) {
        checkNotNull(request, "The parameter request should NOT be null.");

        checkStringNotEmpty(request.getPlayDomain(), "playDomain should NOT be empty.");
        checkStringNotEmpty(request.getApp(), "App should NOT be empty.");
        checkStringNotEmpty(request.getStream(), "Stream should NOT be empty.");

        InternalRequest internalRequest = createRequest(HttpMethodName.GET,
                request, LIVE_DOMAIN, request.getPlayDomain(),
                LIVE_APP, request.getApp(),
                LIVE_STREAM, request.getStream());
        return invokeHttpClient(internalRequest, GetStreamResponse.class);
    }
1303204
private final StreamInfo getStreamInfo(String streamKey, SIBUuid12 streamId)
  {
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.entry(tc, "getStreamInfo", new Object[]{streamKey, streamId});
    StreamInfo sinfo = streamTable.get(streamKey);
    if ((sinfo != null) && sinfo.streamId.equals(streamId))
    {
      if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(tc, "getStreamInfo", sinfo);
      return sinfo;
    }

    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(tc, "getStreamInfo", null);
    return null;
  }
905606
public void updateStreamDestinationPushUrl(UpdateStreamDestinationPushUrlRequest request) {
        checkNotNull(request, "The parameter request should NOT be null.");

        checkStringNotEmpty(request.getDomain(), "Domain should NOT be empty.");
        checkStringNotEmpty(request.getApp(), "App should NOT be empty");
        checkStringNotEmpty(request.getStream(), "Stream should NOT be empty.");

        InternalRequest internalRequest = createRequest(HttpMethodName.PUT, request, LIVE_DOMAIN,
                request.getDomain(), LIVE_APP, request.getApp(), LIVE_STREAM, request.getStream());
        internalRequest.addParameter("destinationPushUrl", request.getDestinationPushUrl());
        invokeHttpClient(internalRequest, AbstractBceResponse.class);
    }
1170566
public static Response getCreateResponse(App app, String type, InputStream is) {
		try (final Metrics.Context context = Metrics.time(app == null ? null : app.getAppid(),
				RestUtils.class, "crud", "create")) {
			ParaObject content;
			Response entityRes = getEntity(is, Map.class);
			if (entityRes.getStatusInfo() == Response.Status.OK) {
				Map<String, Object> newContent = (Map<String, Object>) entityRes.getEntity();
				String declaredType = (String) newContent.get(Config._TYPE);
				if (!StringUtils.isBlank(type) && (StringUtils.isBlank(declaredType) || !type.startsWith(declaredType))) {
					newContent.put(Config._TYPE, type);
				}
				content = ParaObjectUtils.setAnnotatedFields(newContent);
				if (app != null && content != null && isNotAnApp(type)) {
					warnIfUserTypeDetected(type);
					content.setAppid(app.getAppIdentifier());
					setCreatorid(app, content);
					int typesCount = app.getDatatypes().size();
					app.addDatatypes(content);
					// The reason why we do two validation passes is because we want to return
					// the errors through the API and notify the end user.
					// This is the primary validation pass (validates not only core POJOS but also user defined objects).
					String[] errors = validateObject(app, content);
					if (errors.length == 0) {
						// Secondary validation pass called here. Object is validated again before being created
						// See: IndexAndCacheAspect.java
						String id = content.create();
						if (id != null) {
							// new type added so update app object
							if (typesCount < app.getDatatypes().size()) {
								app.update();
							}
							return Response.created(URI.create(Utils.urlEncode(content.getObjectURI()))).
									entity(content).build();
						}
					}
					return getStatusResponse(Response.Status.BAD_REQUEST, errors);
				}
				return getStatusResponse(Response.Status.BAD_REQUEST, "Failed to create object.");
			}
			return entityRes;
		}
	}
1374797
public String RTMPPlayURL(String domain, String hub, String streamKey) {
        return String.format("rtmp://%s/%s/%s", domain, hub, streamKey);
    }
1281514
public static dnssoarec get(nitro_service service, String domain) throws Exception{
		dnssoarec obj = new dnssoarec();
		obj.set_domain(domain);
		dnssoarec response = (dnssoarec) obj.get_resource(service);
		return response;
	}
1337825
public PauseDomainStreamResponse pauseDomainStream(PauseDomainStreamRequest request) {
        checkNotNull(request, "The parameter request should NOT be null.");

        checkStringNotEmpty(request.getDomain(), "Domain should NOT be empty.");
        checkStringNotEmpty(request.getApp(), "App should NOT be empty.");
        checkStringNotEmpty(request.getStream(), "Stream should NOT be empty.");

        InternalRequest internalRequest = createRequest(HttpMethodName.PUT,
                request, LIVE_DOMAIN, request.getDomain(),
                LIVE_APP, request.getApp(),
                LIVE_STREAM, request.getStream());
        internalRequest.addParameter(PAUSE, null);
        return invokeHttpClient(internalRequest, PauseDomainStreamResponse.class);
    }
491335
public OvhAsyncTask<OvhHubicDetailsResponse> packName_hubic_services_domain_details_GET(String packName, String domain) throws IOException {
		String qPath = "/pack/xdsl/{packName}/hubic/services/{domain}/details";
		StringBuilder sb = path(qPath, packName, domain);
		String resp = exec(qPath, "GET", sb.toString(), null);
		return convertTo(resp, t12);
	}
432588
function getDomain(domain, callback) {
    getAll(function onGetAll(err, domains) {
      if (err) {
        return callback(err);
      }

      callback(null, domains.results.filter(function onGetDomain(domain_obj) {
        return domain_obj.domain == domain;
      })[0]);
    });
  }
1159293
@Override
    @Deprecated
    public CompletableFuture<io.pravega.client.batch.StreamInfo> getStreamInfo(final Stream stream) {
        Preconditions.checkNotNull(stream, "stream");

        StreamManagerImpl streamManager = new StreamManagerImpl(this.controller, this.connectionFactory);
        return streamManager.getStreamInfo(stream)
                            .thenApply(info -> new io.pravega.client.batch.StreamInfo(
                                    info.getScope(), info.getStreamName(), info.getTailStreamCut(), info.getHeadStreamCut()));
    }
810260
public OvhClaimNotice data_claimNotice_GET(String domain) throws IOException {
		String qPath = "/domain/data/claimNotice";
		StringBuilder sb = path(qPath);
		query(sb, "domain", domain);
		String resp = execN(qPath, "GET", sb.toString(), null);
		return convertTo(resp, OvhClaimNotice.class);
	}
1175736
public InputStream getInputStream(URI uri, SecurityDomain securityDomain) throws NoSecurityDomainException, MalformedURLException, IOException, NoSuchAlgorithmException {
        final NodeAuthModuleContext context = NodeAuthModuleContext.getContext();
        if (!context.isTLSEnabled() && !context.isNonTLSConnectionsPermitted()) {
            throw new NoSuchAlgorithmException("TLS has been disabled for ATNA connections");
        }

        boolean tlsURI = uri.getScheme().equalsIgnoreCase("https");
        boolean useTLS = tlsURI && context.isTLSEnabled() || !context.isNonTLSConnectionsPermitted();

        if (useTLS && null == securityDomain) {
            throw new NoSecurityDomainException(uri, "Security domain provided is null");
        }

        if (useTLS) {
            securityDomain.setDomainEnvironment();
        }
        InputStream is = null;
        try {
            URLConnection connection = uri.toURL().openConnection();

            if (useTLS && !securityDomain.doDomainSpoofCheck()) {
                ((HttpsURLConnection) connection).setHostnameVerifier((urlHostName, session) -> true);
            }

            is = connection.getInputStream();
            if (useTLS) {
                logger.info("Secure connection successfully made using TLS to " + uri.toString());
            } else {
                logger.info("Unsecure connection successfully made to " + uri.toString());
            }
        } catch (IOException e) {
            if (useTLS) securityDomain.restoreSystemEnvironment();
            throw e;
        }

        if (useTLS) securityDomain.restoreSystemEnvironment();
        return is;
    }
1369702
@Override
	public <T> T get(final String key, DomainResolver resolver) {
		return get(key, null, resolver);
	}
957667
public Observable<List<Domain>> getDomainsAsync() {
        return getDomainsWithServiceResponseAsync().map(new Func1<ServiceResponse<List<Domain>>, List<Domain>>() {
            @Override
            public List<Domain> call(ServiceResponse<List<Domain>> response) {
                return response.body();
            }
        });
    }