public void SubsequentInvocations()
{
GrpcEnvironment.Initialize();
GrpcEnvironment.Initialize();
GrpcEnvironment.Shutdown();
GrpcEnvironment.Shutdown();
}
private void Run()
{
GrpcEnvironment.Initialize();
string addr = string.Format("{0}:{1}", options.serverHost, options.serverPort);
Credentials credentials = null;
if (options.useTls)
{
credentials = TestCredentials.CreateTestClientCredentials(options.useTestCa);
}
ChannelArgs channelArgs = null;
if (!string.IsNullOrEmpty(options.serverHostOverride))
{
channelArgs = ChannelArgs.CreateBuilder()
.AddString(ChannelArgs.SslTargetNameOverrideKey, options.serverHostOverride).Build();
}
using (Channel channel = new Channel(addr, credentials, channelArgs))
{
TestServiceGrpc.ITestServiceClient client = new TestServiceGrpc.TestServiceClientStub(channel);
RunTestCase(options.testCase, client);
}
GrpcEnvironment.Shutdown();
}
internal void RemoveFromTracker(
[DefaultValue((uint)7089), Description("GRPC port")] uint grpcPort)
{
Initialize();
// We need to initialize this here because there's no codepath otherwise.
GrpcEnvironment.Initialize();
var context = new Context(_logger);
var retryPolicy = RetryPolicyFactory.GetLinearPolicy(ex => ex is ClientCanRetryException, (int)_retryCount, TimeSpan.FromSeconds(_retryIntervalSeconds));
_logger.Debug("Begin repair handling...");
// This action is synchronous to make sure the calling application doesn't exit before the method returns.
using (var rpcClient = new GrpcRepairClient(grpcPort))
{
var removeFromTrackerResult = retryPolicy.ExecuteAsync(() => rpcClient.RemoveFromTrackerAsync(context), _cancellationToken).Result;
if (!removeFromTrackerResult.Succeeded)
{
throw new CacheException(removeFromTrackerResult.ErrorMessage);
}
else
{
_logger.Debug($"Repair handling succeeded. Removed {removeFromTrackerResult.Data} hashes from the content tracker.");
}
var shutdownResult = rpcClient.ShutdownAsync(context).Result;
if (!shutdownResult.Succeeded)
{
throw new CacheException(shutdownResult.ErrorMessage);
}
}
}
private void Run()
{
GrpcEnvironment.Initialize();
var server = new Server();
server.AddServiceDefinition(TestService.BindService(new TestServiceImpl()));
string host = "0.0.0.0";
int port = options.port.Value;
if (options.useTls)
{
server.AddListeningPort(host, port, TestCredentials.CreateTestServerCredentials());
}
else
{
server.AddListeningPort(host, options.port.Value);
}
Console.WriteLine("Running server on " + string.Format("{0}:{1}", host, port));
server.Start();
server.ShutdownTask.Wait();
GrpcEnvironment.Shutdown();
}
static void Main(string[] args)
{
GrpcEnvironment.Initialize();
using (Channel channel = new Channel("127.0.0.1:50052"))
{
var client = new RouteGuideClient(RouteGuide.NewStub(channel));
// Looking for a valid feature
client.GetFeature(409146138, -746188906);
// Feature missing.
client.GetFeature(0, 0);
// Looking for features between 40, -75 and 42, -73.
client.ListFeatures(400000000, -750000000, 420000000, -730000000).Wait();
// Record a few randomly selected points from the features file.
client.RecordRoute(RouteGuideUtil.ParseFeatures(RouteGuideUtil.DefaultFeaturesFile), 10).Wait();
// Send and receive some notes.
client.RouteChat().Wait();
}
GrpcEnvironment.Shutdown();
}
private void Run()
{
GrpcEnvironment.Initialize();
var server = new Server();
server.AddServiceDefinition(TestServiceGrpc.BindService(new TestServiceImpl()));
string addr = "0.0.0.0:" + options.port;
if (options.useTls)
{
server.AddListeningPort(addr, TestCredentials.CreateTestServerCredentials());
}
else
{
server.AddListeningPort(addr);
}
Console.WriteLine("Running server on " + addr);
server.Start();
server.ShutdownTask.Wait();
GrpcEnvironment.Shutdown();
}
public CacheServerDistributedContentTests(
LocalRedisFixture redis,
ITestOutputHelper output)
: base(redis, output)
{
UseGrpcServer = true;
GrpcEnvironment.Initialize(TestGlobal.Logger, new BuildXL.Cache.ContentStore.Grpc.GrpcEnvironmentOptions()
{
LoggingVerbosity = BuildXL.Cache.ContentStore.Grpc.GrpcEnvironmentOptions.GrpcVerbosity.Info
});
}
static void Main(string[] args)
{
GrpcEnvironment.Initialize();
GrainClient.Initialize("DevTestClientConfiguration.xml");
ProcessManager manager = new ProcessManager();
manager.SubscribeNotification();
Console.ReadLine();
GrpcEnvironment.Shutdown();
}
public void StartAndShutdownServer()
{
GrpcEnvironment.Initialize();
Server server = new Server();
server.AddListeningPort("localhost:0");
server.Start();
server.ShutdownAsync().Wait();
GrpcEnvironment.Shutdown();
}
public void Init()
{
GrpcEnvironment.Initialize();
server = new Server();
server.AddServiceDefinition(TestServiceGrpc.BindService(new TestServiceImpl()));
int port = server.AddPort(host + ":0");
server.Start();
channel = new Channel(host + ":" + port);
client = TestServiceGrpc.NewStub(channel);
}
public void InitializeAfterShutdown()
{
GrpcEnvironment.Initialize();
var tp1 = GrpcEnvironment.ThreadPool;
GrpcEnvironment.Shutdown();
GrpcEnvironment.Initialize();
var tp2 = GrpcEnvironment.ThreadPool;
GrpcEnvironment.Shutdown();
Assert.IsFalse(Object.ReferenceEquals(tp1, tp2));
}
private void Run()
{
GrpcEnvironment.Initialize();
string addr = string.Format("{0}:{1}", options.serverHost, options.serverPort);
using (Channel channel = new Channel(addr))
{
TestServiceGrpc.ITestServiceClient client = new TestServiceGrpc.TestServiceClientStub(channel);
RunTestCase(options.testCase, client);
}
GrpcEnvironment.Shutdown();
}
public SessionManager(Guid id, int port)
{
gameId = id;
gameRunning = 0;
rpcPort = port;
controller = new SessionController(this);
currentSession = new SessionImpl(gameId, Constants.SessionDuration);
launchEvent = new ManualResetEvent(false);
GrpcEnvironment.Initialize();
rpcServer = new Server();
rpcServer.AddServiceDefinition(Controller.BindService(controller));
rpcServer.AddListeningPort("localhost", rpcPort);
rpcServer.Start();
}
public void Init()
{
GrpcEnvironment.Initialize();
server = new Server();
server.AddServiceDefinition(TestServiceGrpc.BindService(new TestServiceImpl()));
int port = server.AddListeningPort(host + ":0", TestCredentials.CreateTestServerCredentials());
server.Start();
var channelArgs = ChannelArgs.CreateBuilder()
.AddString(ChannelArgs.SslTargetNameOverrideKey, TestCredentials.DefaultHostOverride).Build();
channel = new Channel(host + ":" + port, TestCredentials.CreateTestClientCredentials(true), channelArgs);
client = TestServiceGrpc.NewStub(channel);
}
public static void Main(string[] args)
{
GrpcEnvironment.Initialize();
using (Channel channel = new Channel("127.0.0.1:50051"))
{
var client = Greeter.NewStub(channel);
String user = "******";
var reply = client.SayHello(new HelloRequest.Builder {
Name = user
}.Build());
Console.WriteLine("Greeting: " + reply.Message);
}
GrpcEnvironment.Shutdown();
}
private void Run()
{
GrpcEnvironment.Initialize();
var server = new Server();
server.AddServiceDefinition(TestServiceGrpc.BindService(new TestServiceImpl()));
string addr = "0.0.0.0:" + options.port;
server.AddPort(addr);
Console.WriteLine("Running server on " + addr);
server.Start();
server.ShutdownTask.Wait();
GrpcEnvironment.Shutdown();
}
/// <summary>
/// Initializes a new instance of the <see cref="ServiceClientContentStore"/> class.
/// </summary>
public ServiceClientContentStore(
ILogger logger,
IAbsFileSystem fileSystem,
ServiceClientContentStoreConfiguration configuration)
{
Contract.Requires(logger != null);
Contract.Requires(fileSystem != null);
Contract.Requires(configuration != null);
Logger = logger;
FileSystem = fileSystem;
Configuration = configuration;
// We need to be able to initialize the gRPC environment on the client side. This MUST happen before our
// first gRPC connection is created, due to the possibility that we may set options that can only be set at
// that point in time. Hence, we do so here, which is the main entrypoint for most of our clients.
GrpcEnvironment.Initialize(Logger, Configuration.GrpcEnvironmentOptions, overwriteSafeOptions: true);
}
public static void Main(string[] args)
{
GrpcEnvironment.Initialize();
Server server = new Server();
server.AddServiceDefinition(Greeter.BindService(new GreeterImpl()));
int port = server.AddListeningPort("localhost", 50051);
server.Start();
Console.WriteLine("Greeter server listening on port " + port);
Console.WriteLine("Press any key to stop the server...");
Console.ReadKey();
server.ShutdownAsync().Wait();
GrpcEnvironment.Shutdown();
}
public static void Main(string[] args)
{
GrpcEnvironment.Initialize();
using (Channel channel = new Channel("127.0.0.1:23456"))
{
MathGrpc.IMathServiceClient stub = new MathGrpc.MathServiceClientStub(channel);
MathExamples.DivExample(stub);
MathExamples.FibExample(stub);
MathExamples.SumExample(stub);
MathExamples.DivManyExample(stub);
}
GrpcEnvironment.Shutdown();
}
public void Init()
{
GrpcEnvironment.Initialize();
server = new Server();
server.AddServiceDefinition(TestService.BindService(new TestServiceImpl()));
int port = server.AddListeningPort(host, Server.PickUnusedPort, TestCredentials.CreateTestServerCredentials());
server.Start();
var options = new List <ChannelOption>
{
new ChannelOption(ChannelOptions.SslTargetNameOverride, TestCredentials.DefaultHostOverride)
};
channel = new Channel(host, port, TestCredentials.CreateTestClientCredentials(true), options);
client = TestService.NewStub(channel);
}
public StartupShutdownBase Create()
{
var cacheConfig = _arguments.Configuration;
if (TryCreateLauncherIfSpecified(cacheConfig, out var launcher))
{
return(launcher);
}
cacheConfig.LocalCasSettings = cacheConfig.LocalCasSettings.FilterUnsupportedNamedCaches(_arguments.HostInfo.Capabilities, _logger);
var distributedSettings = cacheConfig.DistributedContentSettings;
var isLocal = distributedSettings == null || !distributedSettings.IsDistributedContentEnabled;
var serviceConfiguration = CreateServiceConfiguration(
_logger,
_fileSystem,
cacheConfig.LocalCasSettings,
distributedSettings,
new AbsolutePath(_arguments.DataRootPath),
isDistributed: !isLocal);
var localServerConfiguration = CreateLocalServerConfiguration(cacheConfig.LocalCasSettings.ServiceSettings, serviceConfiguration, distributedSettings);
// Initialization of the GrpcEnvironment is nasty business: we have a wrapper class around the internal
// state. The internal state has a flag inside that marks whether it's been initialized or not. If we do
// any Grpc activity, the internal state will be initialized, and all further attempts to change things
// will throw. Since we may need to initialize a Grpc client before we do a Grpc server, this means we
// need to call this early, even if it doesn't have anything to do with what's going on here.
GrpcEnvironment.Initialize(_logger, localServerConfiguration.GrpcEnvironmentOptions, overwriteSafeOptions: true);
if (isLocal)
{
// In practice, we don't really pass in a null distributedSettings. Hence, we'll enable the metadata
// store whenever its set to true. This can only happen in the Application verb, because the Service
// verb doesn't change the defaults.
return(CreateLocalServer(localServerConfiguration, distributedSettings));
}
else
{
return(CreateDistributedServer(localServerConfiguration, distributedSettings));
}
}
public void Init()
{
GrpcEnvironment.Initialize();
server = new Server();
server.AddServiceDefinition(Math.BindService(new MathServiceImpl()));
int port = server.AddListeningPort(host, Server.PickUnusedPort);
server.Start();
channel = new Channel(host, port);
// TODO(jtattermusch): get rid of the custom header here once we have dedicated tests
// for header support.
var stubConfig = new StubConfiguration((headerBuilder) =>
{
headerBuilder.Add(new Metadata.MetadataEntry("customHeader", "abcdef"));
});
client = Math.NewStub(channel, stubConfig);
}
static void Main(string[] args)
{
var features = RouteGuideUtil.ParseFeatures(RouteGuideUtil.DefaultFeaturesFile);
GrpcEnvironment.Initialize();
Server server = new Server();
server.AddServiceDefinition(RouteGuide.BindService(new RouteGuideImpl(features)));
int port = server.AddListeningPort("localhost", 50052);
server.Start();
Console.WriteLine("RouteGuide server listening on port " + port);
Console.WriteLine("Press any key to stop the server...");
Console.ReadKey();
server.ShutdownAsync().Wait();
GrpcEnvironment.Shutdown();
}
public static void Main(string[] args)
{
string host = "0.0.0.0";
GrpcEnvironment.Initialize();
Server server = new Server();
server.AddServiceDefinition(MathGrpc.BindService(new MathServiceImpl()));
int port = server.AddListeningPort(host + ":23456");
server.Start();
Console.WriteLine("MathServer listening on port " + port);
Console.WriteLine("Press any key to stop the server...");
Console.ReadKey();
server.ShutdownAsync().Wait();
GrpcEnvironment.Shutdown();
}
private void Run()
{
GrpcEnvironment.Initialize();
Credentials credentials = null;
if (options.useTls)
{
credentials = TestCredentials.CreateTestClientCredentials(options.useTestCa);
}
List <ChannelOption> channelOptions = null;
if (!string.IsNullOrEmpty(options.serverHostOverride))
{
channelOptions = new List <ChannelOption>
{
new ChannelOption(ChannelOptions.SslTargetNameOverride, options.serverHostOverride)
};
}
using (Channel channel = new Channel(options.serverHost, options.serverPort.Value, credentials, channelOptions))
{
var stubConfig = StubConfiguration.Default;
if (options.testCase == "service_account_creds" || options.testCase == "compute_engine_creds")
{
var credential = GoogleCredential.GetApplicationDefault();
if (credential.IsCreateScopedRequired)
{
credential = credential.CreateScoped(new[] { AuthScope });
}
stubConfig = new StubConfiguration(OAuth2InterceptorFactory.Create(credential));
}
TestService.ITestServiceClient client = new TestService.TestServiceClient(channel, stubConfig);
RunTestCase(options.testCase, client);
}
GrpcEnvironment.Shutdown();
}
public static void Main(string[] args)
{
GrpcEnvironment.Initialize();
using (Channel channel = new Channel("127.0.0.1", 23456))
{
Math.IMathClient stub = new Math.MathClient(channel);
MathExamples.DivExample(stub);
MathExamples.DivAsyncExample(stub).Wait();
MathExamples.FibExample(stub).Wait();
MathExamples.SumExample(stub).Wait();
MathExamples.DivManyExample(stub).Wait();
MathExamples.DependendRequestsExample(stub).Wait();
}
GrpcEnvironment.Shutdown();
}
public void Init()
{
GrpcEnvironment.Initialize();
}
public GrpcRepairClientTests()
: base(() => new PassThroughFileSystem(TestGlobal.Logger), TestGlobal.Logger)
{
GrpcEnvironment.Initialize();
}
/// <summary>
/// Creates a cache server.
/// </summary>
/// <remarks>
/// Currently it can be one of the following:
/// * Launcher that will download configured bits and start them.
/// * Out-of-proc launcher that will start the current bits in a separate process.
/// * In-proc distributed cache service.
/// * In-proc local cache service.
/// </remarks>
public async Task <StartupShutdownBase> CreateAsync(OperationContext operationContext)
{
var cacheConfig = _arguments.Configuration;
if (IsLauncherEnabled(cacheConfig))
{
_tracer.Debug(operationContext, $"Creating a launcher.");
return(await CreateLauncherAsync(cacheConfig));
}
var distributedSettings = cacheConfig.DistributedContentSettings;
if (IsOutOfProcCacheEnabled(cacheConfig))
{
_tracer.Debug(operationContext, $"Creating an out-of-proc cache service.");
var outOfProcCache = await CacheServiceWrapper.CreateAsync(_arguments);
if (outOfProcCache.Succeeded)
{
return(outOfProcCache.Value);
}
// Tracing and falling back to the in-proc cache
_tracer.Error(operationContext, $"Failed to create out of proc cache: {outOfProcCache}. Using in-proc cache instead.");
}
_tracer.Debug(operationContext, "Creating an in-proc cache service.");
cacheConfig.LocalCasSettings = cacheConfig.LocalCasSettings.FilterUnsupportedNamedCaches(_arguments.HostInfo.Capabilities, _logger);
var isLocal = distributedSettings == null || !distributedSettings.IsDistributedContentEnabled;
if (distributedSettings is not null)
{
LogManager.Update(distributedSettings.LogManager);
}
var serviceConfiguration = CreateServiceConfiguration(
_logger,
_fileSystem,
cacheConfig.LocalCasSettings,
distributedSettings,
new AbsolutePath(_arguments.DataRootPath),
isDistributed: !isLocal);
var localServerConfiguration = CreateLocalServerConfiguration(cacheConfig.LocalCasSettings.ServiceSettings, serviceConfiguration, distributedSettings);
// Initialization of the GrpcEnvironment is nasty business: we have a wrapper class around the internal
// state. The internal state has a flag inside that marks whether it's been initialized or not. If we do
// any Grpc activity, the internal state will be initialized, and all further attempts to change things
// will throw. Since we may need to initialize a Grpc client before we do a Grpc server, this means we
// need to call this early, even if it doesn't have anything to do with what's going on here.
GrpcEnvironment.Initialize(_logger, localServerConfiguration.GrpcEnvironmentOptions, overwriteSafeOptions: true);
if (isLocal)
{
// In practice, we don't really pass in a null distributedSettings. Hence, we'll enable the metadata
// store whenever its set to true. This can only happen in the Application verb, because the Service
// verb doesn't change the defaults.
return(CreateLocalServer(localServerConfiguration, distributedSettings));
}
else
{
return(CreateDistributedServer(localServerConfiguration, distributedSettings));
}
}
public void InitializeAndShutdownGrpcEnvironment()
{
GrpcEnvironment.Initialize();
Assert.IsNotNull(GrpcEnvironment.ThreadPool.CompletionQueue);
GrpcEnvironment.Shutdown();
}