get detail of your stream by app name and stream name

@param app app name
@param stream stream name
@return the response
960932
public GetAppStreamResponse queryAppStream(String app, String stream) {
        GetAppStreamRequest request = new GetAppStreamRequest();
        request.setApp(app);
        request.setStream(stream);
        return queryAppStream(request);
    }
597107
public Application getRegisteredApplications(String appName) {
        return appNameApplicationMap.get(appName.toUpperCase(Locale.ROOT));
    }
1308735
public static appfwwsdl get(nitro_service service, String name) throws Exception{
		appfwwsdl obj = new appfwwsdl();
		obj.set_name(name);
		appfwwsdl response = (appfwwsdl) obj.get_resource(service);
		return response;
	}
184940
public App named(String name) {
        App newApp = copy();
        newApp.name = name;
        return newApp;
    }
425196
public com.google.protobuf.ByteString
      getAppNameSetterBytes() {
    java.lang.Object ref = appNameSetter_;
    if (ref instanceof java.lang.String) {
      com.google.protobuf.ByteString b = 
          com.google.protobuf.ByteString.copyFromUtf8(
              (java.lang.String) ref);
      appNameSetter_ = b;
      return b;
    } else {
      return (com.google.protobuf.ByteString) ref;
    }
  }
1066240
public ListAppStreamsResponse listAppStreams(String app, String status) {
        ListAppStreamsRequest request = new ListAppStreamsRequest();
        request.setApp(app);
        request.setStatus(status);
        return listAppStreams(request);
    }
1212601
public CreateStreamResponse createStream(CreateStreamRequest 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.");
        checkNotNull(request.getPublish(), "publish should NOT be null.");
        checkStringNotEmpty(request.getPublish().getPushStream(), "pushStream should NOT be empty.");

        InternalRequest internalRequest = createRequest(HttpMethodName.POST,
                request, LIVE_DOMAIN, request.getPlayDomain(), LIVE_STREAM);
        return invokeHttpClient(internalRequest, CreateStreamResponse.class);
    }
946451
public Observable<ServiceResponse<PublishSettings>> getPublishSettingsWithServiceResponseAsync(UUID appId) {
        if (this.client.endpoint() == null) {
            throw new IllegalArgumentException("Parameter this.client.endpoint() is required and cannot be null.");
        }
        if (appId == null) {
            throw new IllegalArgumentException("Parameter appId is required and cannot be null.");
        }
        String parameterizedHost = Joiner.on(", ").join("{Endpoint}", this.client.endpoint());
        return service.getPublishSettings(appId, this.client.acceptLanguage(), parameterizedHost, this.client.userAgent())
            .flatMap(new Func1<Response<ResponseBody>, Observable<ServiceResponse<PublishSettings>>>() {
                @Override
                public Observable<ServiceResponse<PublishSettings>> call(Response<ResponseBody> response) {
                    try {
                        ServiceResponse<PublishSettings> clientResponse = getPublishSettingsDelegate(response);
                        return Observable.just(clientResponse);
                    } catch (Throwable t) {
                        return Observable.error(t);
                    }
                }
            });
    }
692881
def find_application(app_id=None, app_name=None):
        
        LOGGER.debug("ApplicationService.find_application")
        if (app_id is None or not app_id) and (app_name is None or not app_name):
            raise exceptions.ArianeCallParametersError('id and name')

        if (app_id is not None and app_id) and (app_name is not None and app_name):
            LOGGER.warn('ApplicationService.find_application - Both id and name are defined. '
                        'Will give you search on id.')
            app_name = None

        params = None
        if app_id is not None and app_id:
            params = {'id': app_id}
        elif app_name is not None and app_name:
            params = {'name': app_name}

        ret = None
        if params is not None:
            args = {'http_operation': 'GET', 'operation_path': 'get', 'parameters': params}
            response = ApplicationService.requester.call(args)
            if response.rc == 0:
                ret = Application.json_2_application(response.response_content)
            elif response.rc != 404:
                err_msg = 'ApplicationService.find_application - Problem while finding application (id:' + \
                          str(app_id) + ', name:' + str(app_name) + '). ' + \
                          'Reason: ' + str(response.response_content) + '-' + str(response.error_message) + \
                          " (" + str(response.rc) + ")"
                LOGGER.warning(
                    err_msg
                )

        return ret
612272
public OvhStream serviceName_output_graylog_stream_streamId_GET(String serviceName, String streamId) throws IOException {
		String qPath = "/dbaas/logs/{serviceName}/output/graylog/stream/{streamId}";
		StringBuilder sb = path(qPath, serviceName, streamId);
		String resp = exec(qPath, "GET", sb.toString(), null);
		return convertTo(resp, OvhStream.class);
	}
1126787
public static Response getOverwriteResponse(App app, String id, String type, InputStream is) {
		try (final Metrics.Context context = Metrics.time(app == null ? null : app.getAppid(),
				RestUtils.class, "crud", "overwrite")) {
			ParaObject content;
			Response entityRes = getEntity(is, Map.class);
			if (entityRes.getStatusInfo() == Response.Status.OK) {
				Map<String, Object> newContent = (Map<String, Object>) entityRes.getEntity();
				if (!StringUtils.isBlank(type)) {
					newContent.put(Config._TYPE, type);
				}
				content = ParaObjectUtils.setAnnotatedFields(newContent);
				if (app != null && content != null && !StringUtils.isBlank(id) && isNotAnApp(type)) {
					warnIfUserTypeDetected(type);
					content.setType(type);
					content.setAppid(app.getAppIdentifier());
					content.setId(id);
					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 && checkIfUserCanModifyObject(app, content)) {
						// Secondary validation pass called here. Object is validated again before being created
						// See: IndexAndCacheAspect.java
						CoreUtils.getInstance().overwrite(app.getAppIdentifier(), content);
						// new type added so update app object
						if (typesCount < app.getDatatypes().size()) {
							app.update();
						}
						return Response.ok(content).build();
					}
					return getStatusResponse(Response.Status.BAD_REQUEST, errors);
				}
				return getStatusResponse(Response.Status.BAD_REQUEST, "Failed to overwrite object.");
			}
			return entityRes;
		}
	}
35646
public List<TagCount> getTagsOnApp(int appId) {
		return getResourceFactory().getApiResource("/tag/app/" + appId + "/")
				.get(new GenericType<List<TagCount>>() { });
	}
299666
public static Response getDeleteResponse(App app, ParaObject content) {
		try (final Metrics.Context context = Metrics.time(app == null ? null : app.getAppid(),
				RestUtils.class, "crud", "delete")) {
			if (app != null && content != null && content.getId() != null && content.getAppid() != null) {
				if (checkImplicitAppPermissions(app, content) && checkIfUserCanModifyObject(app, content)) {
					content.setAppid(isNotAnApp(content.getType()) ? app.getAppIdentifier() : app.getAppid());
					content.delete();
					return Response.ok().build();
				}
				return getStatusResponse(Response.Status.BAD_REQUEST);
			}
			return getStatusResponse(Response.Status.NOT_FOUND);
		}
	}
1180270
public ApplicationState getApplication(final String applicationId) throws IOException {
    final String url = this.getApplicationURL(applicationId);
    final HttpGet get = prepareGet(url);
    try (final CloseableHttpResponse response = this.httpClient.execute(get, this.httpClientContext)) {
      final String message = IOUtils.toString(response.getEntity().getContent());
      final ApplicationResponse result = this.objectMapper.readValue(message, ApplicationResponse.class);
      return result.getApplicationState();
    }
  }
1138236
@Override
	public Response createApplication( Application app ) {

		this.logger.fine( "Request: create application " + app + "." );
		Response result;
		try {
			String tplName = app.getTemplate() == null ? null : app.getTemplate().getName();
			String tplQualifier = app.getTemplate() == null ? null : app.getTemplate().getVersion();
			String appName = app.getDisplayName() != null ? app.getDisplayName() : app.getName();
			ManagedApplication ma = this.manager.applicationMngr().createApplication( appName, app.getDescription(), tplName, tplQualifier );
			result = Response.ok().entity( ma.getApplication()).build();

		} catch( InvalidApplicationException e ) {
			result = handleError(
					Status.NOT_FOUND,
					new RestError( REST_MNGMT_INVALID_TPL, e, application( app )),
					lang( this.manager )).build();

		} catch( AlreadyExistingException e ) {
			result = handleError(
					Status.FORBIDDEN,
					new RestError( REST_MNGMT_CONFLICT, e, application( app )),
					lang( this.manager )).build();

		} catch( IOException e ) {
			result = handleError(
					Status.UNAUTHORIZED,
					new RestError( REST_SAVE_ERROR, e, application( app )),
					lang( this.manager )).build();
		}

		return result;
	}
914440
def get_app_data(app_id):
    
    try:
        conn = get_conn()
        c = conn.cursor()
        c.execute("SELECT id,name,app_data FROM app WHERE id='{0}' ".format(app_id))
        result = c.fetchone()
        conn.close()

        if result:
            appname = result[1]
            app_data = utils.str2dict( base64.b64decode(result[2]) )

            return (appname,app_data)
        else:
            return (None,None)

    except Exception,e:
        raise RuntimeError('get app data failed! %s' % e)
683699
public ResumeDomainStreamResponse resumeDomainStream(String domain, String app, String stream) {
        ResumeDomainStreamRequest request = new ResumeDomainStreamRequest();
        request.withDomain(domain).withApp(app).withStream(stream);
        return resumeDomainStream(request);
    }