public void WaitForChangeTimeout()
{
var client = MetadataClient.Create();
var initialTags = client.WaitForChange("instance/tags", timeout: TimeSpan.FromMilliseconds(1));
var initialAttributes = client.WaitForChange("instance/attributes", timeout: TimeSpan.FromMilliseconds(1));
// Wait for change on a value key
var sw = Stopwatch.StartNew();
var result = client.WaitForChange("instance/tags", timeout: TimeSpan.FromSeconds(7));
sw.Stop();
Assert.Equal(initialTags.Content, result.Content);
Assert.Equal(initialTags.ETag, result.ETag);
Assert.NotNull(result.ETag);
Assert.True(sw.Elapsed.TotalSeconds >= 7);
// Wait for change on a directory key
sw = Stopwatch.StartNew();
result = client.WaitForChange("instance/attributes", timeout: TimeSpan.FromSeconds(5));
sw.Stop();
Assert.Equal(initialAttributes.Content, result.Content);
Assert.Equal(initialAttributes.ETag, result.ETag);
Assert.NotNull(result.ETag);
Assert.True(sw.Elapsed.TotalSeconds >= 5);
}
public void GetMaintenanceStatus()
{
var client = MetadataClient.Create();
var status = client.GetMaintenanceStatus();
Assert.Equal(MaintenanceStatus.None, status);
}
public async Task ProjectMetadataChanged()
{
const string newValue = "foo";
string key = _fixture.GenerateCustomKey();
var client = MetadataClient.Create();
var waitHandle = new ManualResetEventSlim(false);
int eventCount = 0;
client.ProjectMetadataChanged += (s, e) =>
{
Assert.Equal(newValue, e.NewMetadata.CommonInstanceMetadata.Items.FirstOrDefault(i => i.Key == key)?.Value);
eventCount++;
waitHandle.Set();
};
await Task.Delay(TimeSpan.FromSeconds(1));
await _fixture.UpdateMetadataAsync($"project/attributes/{key}", newValue);
waitHandle.Wait(TimeSpan.FromSeconds(10));
Assert.Equal(1, eventCount);
Assert.Equal(newValue, await client.GetCustomProjectMetadataAsync(key));
}
public void GetCustomProjectMetadata()
{
var client = MetadataClient.Create();
var value = client.GetCustomProjectMetadata("my_project_key1");
Assert.Equal("my_project_value1", value);
}
public async Task MaintenanceStatusChanged()
{
var client = MetadataClient.Create();
var waitHandle = new ManualResetEventSlim(false);
int eventCount = 0;
client.MaintenanceStatusChanged += (s, e) =>
{
eventCount++;
waitHandle.Set();
};
try
{
await _fixture.UpdateMetadataAsync("instance/maintenance-event", "MIGRATE_ON_HOST_MAINTENANCE");
waitHandle.Wait(TimeSpan.FromSeconds(10));
Assert.Equal(1, eventCount);
Assert.Equal(MaintenanceStatus.Migrate, client.GetMaintenanceStatus());
}
finally
{
await _fixture.UpdateMetadataAsync("instance/maintenance-event", "NONE");
}
}
public void GetCustomInstanceMetadata()
{
var client = MetadataClient.Create();
var value = client.GetCustomInstanceMetadata("my_instance_key1");
Assert.Equal("my_instance_value1", value);
}
private static Instance GetMetadata()
{
MetadataClient client = MetadataClient.Create();
var instance = client.GetInstanceMetadata();
return(instance);
}
public async Task InstanceMetadataChanged_HookTwice()
{
const string newValue = "foo";
string key = _fixture.GenerateCustomKey();
var client = MetadataClient.Create();
var waitHandle1 = new ManualResetEventSlim(false);
var waitHandle2 = new ManualResetEventSlim(false);
int eventCount = 0;
Instance instance1 = null;
Instance instance2 = null;
client.InstanceMetadataChanged += (s, e) =>
{
instance1 = e.NewMetadata;
Interlocked.Increment(ref eventCount);
waitHandle1.Set();
};
client.InstanceMetadataChanged += (s, e) =>
{
instance2 = e.NewMetadata;
Interlocked.Increment(ref eventCount);
waitHandle2.Set();
};
await _fixture.UpdateMetadataAsync($"instance/attributes/{key}", newValue);
waitHandle1.Wait(TimeSpan.FromSeconds(10));
waitHandle2.Wait(TimeSpan.FromSeconds(1));
Assert.Equal(2, eventCount);
// Ensure the result string is only parsed once and (indirectly) that we only performed a
// single handing get on the server.
Assert.Same(instance1, instance2);
}
public void GetAccessToken()
{
var client = MetadataClient.Create();
var tokenResponse = client.GetAccessToken();
Assert.Equal("0123456789ABCDEF", tokenResponse.AccessToken);
Assert.Equal(3000, tokenResponse.ExpiresInSeconds.Value);
Assert.Equal("Bearer", tokenResponse.TokenType);
}
public void GetProjectMetadata()
{
var client = MetadataClient.Create();
var project = client.GetProjectMetadata();
Assert.True(project.CommonInstanceMetadata.Items.Count >= 1);
Assert.Equal("my_project_value1", project.CommonInstanceMetadata.Items.FirstOrDefault(i => i.Key == "my_project_key1")?.Value);
Assert.Equal(12345ul, project.Id.Value);
Assert.Equal("fake-project", project.Name);
}
public void GetCustomInstanceMetadata()
{
// Snippet: GetCustomInstanceMetadata
MetadataClient client = MetadataClient.Create();
string customValue = client.GetCustomInstanceMetadata("my_instance_key1");
Console.WriteLine(customValue);
// End snippet
Assert.Equal("my_instance_value1", customValue);
}
public void GetInstanceMetadata()
{
// Snippet: GetInstanceMetadata
MetadataClient client = MetadataClient.Create();
Instance instance = client.GetInstanceMetadata();
Console.Write(instance.Zone);
// End snippet
Assert.Equal(instance.Zone, "projects/12345/zones/us-central1-f");
}
public async Task WaitForChange()
{
const string newValue = "foo";
string key = _fixture.GenerateCustomKey();
await _fixture.UpdateMetadataAsync($"instance/attributes/{key}", "initial value");
var task = Task.Run(async() =>
{
await Task.Delay(TimeSpan.FromSeconds(2));
await _fixture.UpdateMetadataAsync($"instance/attributes/{key}", newValue);
});
// Snippet: WaitForChange
MetadataClient client = MetadataClient.Create();
// Get the original metadata and its ETag so we know when the metadata changes.
MetadataResult initialResult = client.GetMetadata("instance/attributes");
Console.WriteLine("Initial Metadata:");
JObject initialMetadata = JObject.Parse(initialResult.Content);
foreach (JProperty property in initialMetadata.Properties())
{
Console.WriteLine(property.Name + " = " + property.Value);
}
string lastETag = initialResult.ETag;
MetadataResult changeResult;
while (true)
{
// Wait in 30 second blocks until the value actually changes.
changeResult = client.WaitForChange("instance/attributes", lastETag, TimeSpan.FromSeconds(30));
if (changeResult.ETag != lastETag)
{
Console.WriteLine("Changed Metadata:");
JObject currentMetadata = JObject.Parse(changeResult.Content);
foreach (JProperty property in currentMetadata.Properties())
{
Console.WriteLine(property.Name + " = " + property.Value);
}
break;
}
}
// End snippet
dynamic obj = JsonConvert.DeserializeObject(changeResult.Content);
Assert.Equal(newValue, obj[key].Value);
await task;
}
public void GetMaintenanceStatus()
{
// Snippet: GetMaintenanceStatus
MetadataClient client = MetadataClient.Create();
MaintenanceStatus status = client.GetMaintenanceStatus();
if (status == MaintenanceStatus.Migrate)
{
// Backup data
}
// End snippet
Assert.Equal(MaintenanceStatus.None, status);
}
public void GetMetadata()
{
// Snippet: GetMetadata
MetadataClient client = MetadataClient.Create();
MetadataResult result = client.GetMetadata("instance/attributes");
JObject initialMetadata = JObject.Parse(result.Content);
foreach (JProperty property in initialMetadata.Properties())
{
Console.WriteLine(property.Name + " = " + property.Value);
}
// End snippet
}
public void GetCustomProjectMetadata_Validations()
{
var client = MetadataClient.Create();
Assert.Throws <ArgumentException>(() => client.GetCustomProjectMetadata(""));
Assert.Throws <ArgumentException>(() => client.GetCustomProjectMetadata("a b"));
Assert.Throws <ArgumentException>(() => client.GetCustomProjectMetadata("a^b"));
Assert.Throws <ArgumentException>(() => client.GetCustomProjectMetadata(
"0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF"));
Assert.ThrowsAsync <ArgumentException>(() => client.GetCustomProjectMetadataAsync(""));
Assert.ThrowsAsync <ArgumentException>(() => client.GetCustomProjectMetadataAsync("a b"));
Assert.ThrowsAsync <ArgumentException>(() => client.GetCustomProjectMetadataAsync("a^b"));
Assert.ThrowsAsync <ArgumentException>(() => client.GetCustomProjectMetadataAsync(
"0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF"));
}
public void WaitForChange_Validations()
{
var client = MetadataClient.Create();
Assert.Throws <ArgumentException>(() => client.WaitForChange("a b"));
Assert.Throws <ArgumentException>(() => client.WaitForChange("a?b"));
Assert.Throws <ArgumentException>(() => client.WaitForChange("http://www.google.com"));
Assert.Throws <ArgumentException>(() => client.WaitForChange("instance", lastETag: "bad-etag"));
Assert.Throws <ArgumentException>(() => client.WaitForChange("instance", timeout: TimeSpan.FromSeconds(-1)));
Assert.ThrowsAsync <ArgumentException>(() => client.WaitForChangeAsync("a b"));
Assert.ThrowsAsync <ArgumentException>(() => client.WaitForChangeAsync("a?b"));
Assert.ThrowsAsync <ArgumentException>(() => client.WaitForChangeAsync("http://www.google.com"));
Assert.ThrowsAsync <ArgumentException>(() => client.WaitForChangeAsync("instance", lastETag: "bad-etag"));
Assert.ThrowsAsync <ArgumentException>(() => client.WaitForChangeAsync("instance", timeout: TimeSpan.FromSeconds(-1)));
}
public async Task WaitForChange()
{
const string newValue = "foo";
string key = _fixture.GenerateCustomKey();
await _fixture.UpdateMetadataAsync($"instance/attributes/{key}", "initial value");
var task = Task.Run(async() =>
{
await Task.Delay(TimeSpan.FromSeconds(2));
await _fixture.UpdateMetadataAsync($"instance/attributes/{key}", newValue);
});
// TODO: This pattern to get the original ETag seems messy. Maybe add something to get an ETag.
// Snippet: WaitForChange
MetadataClient client = MetadataClient.Create();
// Get the original ETag so we know when the metadata changes.
string lastETag = client.WaitForChange("instance/attributes", timeout: TimeSpan.FromMilliseconds(1)).ETag;
WaitForChangeResult result;
while (true)
{
// Wait in 30 second blocks until the value actually changes.
result = client.WaitForChange("instance/attributes", lastETag, TimeSpan.FromSeconds(30));
if (result.ETag != lastETag)
{
JObject currentCustomMetadata = JObject.Parse(result.Content);
foreach (JProperty customMetadata in currentCustomMetadata.Properties())
{
Console.WriteLine(customMetadata.Name + " = " + customMetadata.Value);
}
break;
}
}
// End snippet
dynamic obj = JsonConvert.DeserializeObject(result.Content);
Assert.Equal(newValue, obj[key].Value);
await task;
}
public void GetInstanceMetadata()
{
var client = MetadataClient.Create();
var instance = client.GetInstanceMetadata();
Assert.Equal("Intel Haswell", instance.CpuPlatform);
Assert.Equal("Fake instance for metadata server emulator", instance.Description);
Assert.Equal("boot", instance.Disks[0].DeviceName);
Assert.Equal(0, instance.Disks[0].Index);
Assert.Equal("READ_WRITE", instance.Disks[0].Mode);
Assert.Equal("PERSISTENT", instance.Disks[0].Type);
Assert.Equal(67890ul, instance.Id.Value);
Assert.Equal("projects/12345/machineTypes/n1-standard-1", instance.MachineType);
Assert.True(instance.Metadata.Items.Count >= 1);
Assert.Equal("my_instance_value1", instance.Metadata.Items.FirstOrDefault(i => i.Key == "my_instance_key1")?.Value);
Assert.Equal("name.project.google.com.internal", instance.Name);
Assert.Equal(1, instance.NetworkInterfaces.Count);
Assert.Equal(1, instance.NetworkInterfaces[0].AccessConfigs.Count);
Assert.Equal("0.0.0.0", instance.NetworkInterfaces[0].AccessConfigs[0].NatIP);
Assert.Equal("ONE_TO_ONE_NAT", instance.NetworkInterfaces[0].AccessConfigs[0].Type);
Assert.Equal("projects/12345/networks/default", instance.NetworkInterfaces[0].Network);
Assert.Equal("0.0.0.0", instance.NetworkInterfaces[0].NetworkIP);
Assert.Equal(true, instance.Scheduling.AutomaticRestart);
Assert.Equal("MIGRATE", instance.Scheduling.OnHostMaintenance);
Assert.Equal(false, instance.Scheduling.Preemptible);
Assert.Equal(2, instance.ServiceAccounts.Count);
Assert.Equal("*****@*****.**", instance.ServiceAccounts[0].Email);
Assert.Equal(2, instance.ServiceAccounts[0].Scopes.Count);
Assert.Equal("https://www.googleapis.com/auth/cloud-platform", instance.ServiceAccounts[0].Scopes[0]);
Assert.Equal("https://www.googleapis.com/auth/userinfo.email", instance.ServiceAccounts[0].Scopes[1]);
Assert.Equal("default", instance.ServiceAccounts[1].Email);
Assert.Equal(2, instance.ServiceAccounts[1].Scopes.Count);
Assert.Equal("https://www.googleapis.com/auth/cloud-platform", instance.ServiceAccounts[1].Scopes[0]);
Assert.Equal("https://www.googleapis.com/auth/userinfo.email", instance.ServiceAccounts[1].Scopes[1]);
Assert.Equal(3, instance.Tags.Items.Count);
Assert.Equal("a", instance.Tags.Items[0]);
Assert.Equal("b", instance.Tags.Items[1]);
Assert.Equal("c", instance.Tags.Items[2]);
Assert.Equal("projects/12345/zones/us-central1-f", instance.Zone);
}
public async Task ProjectMetadataChanged()
{
const string newValue = "foo";
string key = _fixture.GenerateCustomKey();
await _fixture.UpdateMetadataAsync($"project/attributes/{key}", "initial value");
var client = MetadataClient.Create();
var waitHandle = new ManualResetEventSlim(false);
int eventCount = 0;
client.ProjectMetadataChanged += (s, e) =>
{
eventCount++;
waitHandle.Set();
};
await _fixture.UpdateMetadataAsync($"project/attributes/{key}", newValue);
waitHandle.Wait(TimeSpan.FromSeconds(10));
Assert.Equal(1, eventCount);
Assert.Equal(newValue, await client.GetCustomProjectMetadataAsync(key));
}
public void WaitForChange()
{
const string newValue = "foo";
string key = _fixture.GenerateCustomKey();
var task = Task.Run(async() =>
{
await Task.Delay(TimeSpan.FromSeconds(1));
await _fixture.UpdateMetadataAsync($"instance/attributes/{key}", newValue);
});
try
{
var client = MetadataClient.Create();
var result = client.WaitForChange("instance/attributes");
dynamic obj = JsonConvert.DeserializeObject(result.Content);
Assert.Equal(newValue, obj[key].Value);
Assert.NotNull(result.ETag);
}
finally
{
task.Wait();
}
}
protected MetadataFixtureBase()
{
var typeInfo = typeof(MetadataFixtureBase).GetTypeInfo();
emulatorPath = Path.Combine(Path.GetTempPath(), Path.GetRandomFileName());
Directory.CreateDirectory(emulatorPath);
Func <string, string> copyResource = name =>
{
var destination = Path.Combine(emulatorPath, name);
using (var input = typeInfo.Assembly.GetManifestResourceStream($"{typeInfo.Namespace}.Emulator.{name}"))
using (var output = File.Create(destination))
{
input.CopyTo(output);
return(destination);
}
};
copyResource("common.py");
copyResource("initial_data.json");
var emulatorFilePath = copyResource("metadata_server.py");
var temp = new TcpListener(IPAddress.Loopback, 0);
temp.Start();
int port = ((IPEndPoint)temp.LocalEndpoint).Port;
temp.Stop();
emulatorHost = $"localhost:{port}";
Environment.SetEnvironmentVariable(EmulatorEnvironmentVariable, emulatorHost);
var startInfo = new ProcessStartInfo("python", $"{emulatorFilePath} --test --port {port}");
startInfo.RedirectStandardError = true;
startInfo.RedirectStandardOutput = true;
startInfo.UseShellExecute = false;
emulatorProcess = new Process {
StartInfo = startInfo, EnableRaisingEvents = true
};
emulatorProcess.Exited += EmulatorProcess_Exited;
emulatorProcess.OutputDataReceived += (sender, e) =>
{
if (e.Data != null)
{
emulatorOutput.AppendLine(e.Data);
}
};
emulatorProcess.ErrorDataReceived += (sender, e) =>
{
if (e.Data != null)
{
emulatorErrorOutput.AppendLine(e.Data);
}
};
emulatorProcess.Start();
emulatorProcess.BeginOutputReadLine();
emulatorProcess.BeginErrorReadLine();
// Block until the server becomes available.
var client = MetadataClient.Create();
var sw = Stopwatch.StartNew();
while (!client.IsServerAvailable() && sw.Elapsed.TotalSeconds < 30)
{
Thread.Sleep(50);
}
if (!client.IsServerAvailable())
{
Cleanup();
ThrowEmulatorError("The metadata server emulator failed to start");
}
}
public void IsServerAvailable()
{
var client = MetadataClient.Create();
Assert.True(client.IsServerAvailable());
}
