public void GetMetadataResourceNames()
        {
            moq::Mock <AlphaAnalyticsData.AlphaAnalyticsDataClient> mockGrpcClient = new moq::Mock <AlphaAnalyticsData.AlphaAnalyticsDataClient>(moq::MockBehavior.Strict);
            GetMetadataRequest request = new GetMetadataRequest
            {
                MetadataName = MetadataName.FromProperty("[PROPERTY]"),
            };
            Metadata expectedResponse = new Metadata
            {
                Dimensions =
                {
                    new DimensionMetadata(),
                },
                Metrics =
                {
                    new MetricMetadata(),
                },
                MetadataName = MetadataName.FromProperty("[PROPERTY]"),
            };

            mockGrpcClient.Setup(x => x.GetMetadata(request, moq::It.IsAny <grpccore::CallOptions>())).Returns(expectedResponse);
            AlphaAnalyticsDataClient client = new AlphaAnalyticsDataClientImpl(mockGrpcClient.Object, null);
            Metadata response = client.GetMetadata(request.MetadataName);

            xunit::Assert.Same(expectedResponse, response);
            mockGrpcClient.VerifyAll();
        }
        public async stt::Task GetMetadataResourceNamesAsync()
        {
            moq::Mock <AlphaAnalyticsData.AlphaAnalyticsDataClient> mockGrpcClient = new moq::Mock <AlphaAnalyticsData.AlphaAnalyticsDataClient>(moq::MockBehavior.Strict);
            GetMetadataRequest request = new GetMetadataRequest
            {
                MetadataName = MetadataName.FromProperty("[PROPERTY]"),
            };
            Metadata expectedResponse = new Metadata
            {
                Dimensions =
                {
                    new DimensionMetadata(),
                },
                Metrics =
                {
                    new MetricMetadata(),
                },
                MetadataName = MetadataName.FromProperty("[PROPERTY]"),
            };

            mockGrpcClient.Setup(x => x.GetMetadataAsync(request, moq::It.IsAny <grpccore::CallOptions>())).Returns(new grpccore::AsyncUnaryCall <Metadata>(stt::Task.FromResult(expectedResponse), null, null, null, null));
            AlphaAnalyticsDataClient client = new AlphaAnalyticsDataClientImpl(mockGrpcClient.Object, null);
            Metadata responseCallSettings   = await client.GetMetadataAsync(request.MetadataName, gaxgrpc::CallSettings.FromCancellationToken(st::CancellationToken.None));

            xunit::Assert.Same(expectedResponse, responseCallSettings);
            Metadata responseCancellationToken = await client.GetMetadataAsync(request.MetadataName, st::CancellationToken.None);

            xunit::Assert.Same(expectedResponse, responseCancellationToken);
            mockGrpcClient.VerifyAll();
        }
 /// <summary>Snippet for GetMetadata</summary>
 /// <remarks>
 /// This snippet has been automatically generated for illustrative purposes only.
 /// It may require modifications to work in your environment.
 /// </remarks>
 public void GetMetadataRequestObject()
 {
     // Create client
     BetaAnalyticsDataClient betaAnalyticsDataClient = BetaAnalyticsDataClient.Create();
     // Initialize request argument(s)
     GetMetadataRequest request = new GetMetadataRequest
     {
         MetadataName = MetadataName.FromProperty("[PROPERTY]"),
     };
     // Make the request
     Metadata response = betaAnalyticsDataClient.GetMetadata(request);
 }
        /// <summary>Snippet for GetMetadataAsync</summary>
        /// <remarks>
        /// This snippet has been automatically generated for illustrative purposes only.
        /// It may require modifications to work in your environment.
        /// </remarks>
        public async Task GetMetadataRequestObjectAsync()
        {
            // Create client
            BetaAnalyticsDataClient betaAnalyticsDataClient = await BetaAnalyticsDataClient.CreateAsync();

            // Initialize request argument(s)
            GetMetadataRequest request = new GetMetadataRequest
            {
                MetadataName = MetadataName.FromProperty("[PROPERTY]"),
            };
            // Make the request
            Metadata response = await betaAnalyticsDataClient.GetMetadataAsync(request);
        }
Пример #5
0
            public static GetMetadataRequest CreateRequest(string source, IEnumerable <string> seriesList, IEnumerable <string> headerList)
            {
                var request = new GetMetadataRequest();

                request.Requestmetadata.Add(new Dictionary <string, string>()
                {
                    { "version", "0.9" }
                });

                request.Metadataheaders.Add(headerList);
                request.Keys.Add(SourceSeriesKeyList.Create(source, seriesList));

                return(request);
            }
Пример #6
0
 /// <summary>Snippet for GetMetadata</summary>
 public void GetMetadataRequestObject()
 {
     // Snippet: GetMetadata(GetMetadataRequest, CallSettings)
     // Create client
     AlphaAnalyticsDataClient alphaAnalyticsDataClient = AlphaAnalyticsDataClient.Create();
     // Initialize request argument(s)
     GetMetadataRequest request = new GetMetadataRequest
     {
         MetadataName = MetadataName.FromProperty("[PROPERTY]"),
     };
     // Make the request
     Metadata response = alphaAnalyticsDataClient.GetMetadata(request);
     // End snippet
 }
Пример #7
0
        /// <summary>Snippet for GetMetadataAsync</summary>
        public async Task GetMetadataRequestObjectAsync()
        {
            // Snippet: GetMetadataAsync(GetMetadataRequest, CallSettings)
            // Additional: GetMetadataAsync(GetMetadataRequest, CancellationToken)
            // Create client
            BetaAnalyticsDataClient betaAnalyticsDataClient = await BetaAnalyticsDataClient.CreateAsync();

            // Initialize request argument(s)
            GetMetadataRequest request = new GetMetadataRequest
            {
                MetadataName = MetadataName.FromProperty("[PROPERTY]"),
            };
            // Make the request
            Metadata response = await betaAnalyticsDataClient.GetMetadataAsync(request);

            // End snippet
        }
Пример #8
0
        public static GetMetadataResponse CallGetMetadata(GetMetadataRequest request)
        {
            var response = new GetMetadataResponse();

            try
            {
                var tssFactory = TimeseriesSourceFactory.Factory;

                //TODO [jc]: what do we do with the requestmetadata?
                response.Responsemetadata.Add(request.Requestmetadata);
                response.Metadataheaders.Add(request.Metadataheaders);

                foreach (var ssKey in request.Keys)
                {
                    var tsList = tssFactory[ssKey.Sourcename].GetMetadata(
                        new[] { new TimeseriesKey(ssKey.Seriesname) },
                        request.Metadataheaders);

                    foreach (var ts in tsList)
                    {
                        var m = new MetadataList
                        {
                            Key = new SourceSeriesKey()
                            {
                                Sourcename = ts.SourceKey.Key.ToString(),
                                Seriesname = ts.SeriesKey.Key
                            }
                        };
                        m.Values.AddRange(ts.Metadata.Values);
                        response.Seriesdata.Add(m);
                    }
                }
            }
            catch (Exception ex)
            {
                IOCContainer.Logger.Error(ex.Message);
                throw;
            }
            IOCContainer.Logger.Info($"GetMetadataResponse: {response.Seriesdata.Count} series found");
            return(response);
        }
 /// <summary>
 /// Returns metadata for dimensions and metrics available in reporting methods.
 /// Used to explore the dimensions and metrics. Dimensions and metrics will be
 /// mostly added over time, but renames and deletions may occur.
 /// </summary>
 /// <param name="request">The request object containing all of the parameters for the API call.</param>
 /// <param name="callSettings">If not null, applies overrides to this RPC call.</param>
 /// <returns>The RPC response.</returns>
 public virtual Metadata GetMetadata(GetMetadataRequest request, gaxgrpc::CallSettings callSettings = null) =>
 throw new sys::NotImplementedException();
Пример #10
0
        private static Metadata GetMetadata()
        {
            try
            {
                ALogger.LogInfo("GetMetadata: getting metadata");

                var metadataObj = Cache.Get(MetaDataCacheKey) as Metadata;

                if(metadataObj != null && metadataObj.enumdict != null && metadataObj.enumdict.Count < 1)
                {
                    ALogger.LogInfo("GetMetadata: get from cache");
                    return metadataObj;
                }

                using (var client = new OpsConsoleServiceClient(RouterBindings.Local, RouterAddresses.Local.RequestReply))
                {
                    var request = new GetMetadataRequest()
                    {
                        product = "est"
                    };
                    var metadataJson = client.GetMetadata(request);

                    metadataObj =  JsonConvert.DeserializeObject<Metadata>(metadataJson);

                    if (metadataObj.enumdict != null && metadataObj.enumdict.Count < 1)
                    {
                        metadataObj = GetLocalMetadata();
                    }

                    Cache.Set(MetaDataCacheKey, metadataObj, DateTimeOffset.UtcNow.AddSeconds(MetaDataCacheTimeoutSecs));
                    return metadataObj;
                }
            }
            catch (Exception ex)
            {
                ALogger.LogError("GetMetadata: Error getting/parsing metadata: {0}", ex.Message);
                return GetLocalMetadata();
            }
        }
Пример #11
0
        private static Metadata GetMetadata(string product = "est")
        {
            if (_estMetaData != null) return _estMetaData;
            try
            {
                _estMetaData = new Metadata { enumdict = new List<EnumDict>(), statcodedict = new List<StatCodeDict>() };
                using (var client = new OpsConsoleServiceClient(RouterBindings.Local, RouterAddresses.Local.RequestReply))
                {
                    var request = new GetMetadataRequest()
                    {
                        product = product
                    };
                    var metadataJson = client.GetMetadata(request);
                    _estMetaData = JsonConvert.DeserializeObject<Metadata>(metadataJson);
                }                
            }
            catch (Exception ex)
            {
                Logger.LogWarn("GetMetadata:, cannot get/convert metadata from OpsConsole service, {0}", ex.Message);

                try
                {
                    using (var sStream = Assembly.GetExecutingAssembly().GetManifestResourceStream("SystemTestService.Schema.json"))
                    {
                        using (var reader = new StreamReader(sStream))
                        {
                            sStream.Seek(0, SeekOrigin.Begin);
                            var metadataJson = reader.ReadToEnd();
                            _estMetaData = JsonConvert.DeserializeObject<Metadata>(metadataJson);
                        }
                    }
                }
                catch (Exception ex2)
                {
                    Logger.LogError("GetMetadata: cannot get metadata from resource file, {0}", ex2.Message);
                    return _estMetaData;
                }
            }
            return _estMetaData;
        }
 /// <summary>
 /// Returns metadata for dimensions and metrics available in reporting methods.
 /// Used to explore the dimensions and metrics. Dimensions and metrics will be
 /// mostly added over time, but renames and deletions may occur.
 /// </summary>
 /// <param name="request">The request object containing all of the parameters for the API call.</param>
 /// <param name="callSettings">If not null, applies overrides to this RPC call.</param>
 /// <returns>The RPC response.</returns>
 public override Metadata GetMetadata(GetMetadataRequest request, gaxgrpc::CallSettings callSettings = null)
 {
     Modify_GetMetadataRequest(ref request, ref callSettings);
     return(_callGetMetadata.Sync(request, callSettings));
 }
 /// <summary>
 /// Returns metadata for dimensions and metrics available in reporting methods.
 /// Used to explore the dimensions and metrics. Dimensions and metrics will be
 /// mostly added over time, but renames and deletions may occur.
 /// </summary>
 /// <param name="request">The request object containing all of the parameters for the API call.</param>
 /// <param name="callSettings">If not null, applies overrides to this RPC call.</param>
 /// <returns>A Task containing the RPC response.</returns>
 public override stt::Task <Metadata> GetMetadataAsync(GetMetadataRequest request, gaxgrpc::CallSettings callSettings = null)
 {
     Modify_GetMetadataRequest(ref request, ref callSettings);
     return(_callGetMetadata.Async(request, callSettings));
 }
 partial void Modify_GetMetadataRequest(ref GetMetadataRequest request, ref gaxgrpc::CallSettings settings);
 /// <summary>
 /// Returns metadata for dimensions and metrics available in reporting methods.
 /// Used to explore the dimensions and metrics. Dimensions and metrics will be
 /// mostly added over time, but renames and deletions may occur.
 /// </summary>
 /// <param name="request">The request object containing all of the parameters for the API call.</param>
 /// <param name="cancellationToken">A <see cref="st::CancellationToken"/> to use for this RPC.</param>
 /// <returns>A Task containing the RPC response.</returns>
 public virtual stt::Task <Metadata> GetMetadataAsync(GetMetadataRequest request, st::CancellationToken cancellationToken) =>
 GetMetadataAsync(request, gaxgrpc::CallSettings.FromCancellationToken(cancellationToken));
 /// <summary>
 /// Returns metadata for dimensions and metrics available in reporting methods.
 /// Used to explore the dimensions and metrics. Dimensions and metrics will be
 /// mostly added over time, but renames and deletions may occur.
 /// </summary>
 /// <param name="request">The request object containing all of the parameters for the API call.</param>
 /// <param name="callSettings">If not null, applies overrides to this RPC call.</param>
 /// <returns>A Task containing the RPC response.</returns>
 public virtual stt::Task <Metadata> GetMetadataAsync(GetMetadataRequest request, gaxgrpc::CallSettings callSettings = null) =>
 throw new sys::NotImplementedException();
Пример #17
0
 public override Task <GetMetadataResponse> GetMetadata(GetMetadataRequest request, ServerCallContext context)
 {
     IOCContainer.Logger.Info("GetMetadata() called");
     return(Task.FromResult(ServerHandler.CallGetMetadata(request)));
 }
Пример #18
0
        private Metadata GetMetadata(string product="est")
        {
            try
            {
                using (var client = new OpsConsoleServiceClient(RouterBindings.Local, RouterAddresses.Local.RequestReply))
                {
                    var request = new GetMetadataRequest()
                    {
                        product = product
                    };
                    var metadataJson = client.GetMetadata(request);

                    return JsonConvert.DeserializeObject<Metadata>(metadataJson);
                }
            }
            catch (Exception ex)
            {
                Logger.LogWarn("GetMetadata: [{0}], cannot get metadata from OpsConsole service, {1}", UUID, ex.Message);
                try
                {
                    using (var sStream = Assembly.GetExecutingAssembly().GetManifestResourceStream("ThomsonReuters.Eikon.SystemTest.Schema.json"))
                    {
                        using (var reader = new StreamReader(sStream))
                        {
                            sStream.Seek(0, SeekOrigin.Begin);
                            var metadataJson = reader.ReadToEnd();
                            return JsonConvert.DeserializeObject<Metadata>(metadataJson);
                        }
                    }
                }
                catch (Exception ex2)
                {
                    Logger.LogError("GetMetadata: [{0}], cannot get metadata from resource file, {1}", UUID, ex2.Message);
                    return null;
                }
            }
        }