public async Task PutEtcdProviderData_Currencies_ReturnsMockCurrencies()
{
// Arrange
const string key = "currencies";
await _polly.ExecuteAsync(async() =>
{
await _etcdClient.DeleteAsync(key);
var value = await _etcdClient.GetValAsync(key);
return(string.IsNullOrEmpty(value));
});
await WriteToEtcdAsync("currencies.json", key);
var currencies = await ReadCurrencyFromEtcdAsync(key);
var dataRetriever = _serviceProvider.GetRequiredService <IDataRetriever <IEnumerable <MockCurrency> > >();
var expectedData = currencies.ToList();
expectedData.First().Code = Guid.NewGuid().ToString();
// Act
await _etcdClient.PutAsync(key, JsonSerializer.Serialize(expectedData));
// Arrange
await _polly.ExecuteAsync(async() =>
{
var actualData = await dataRetriever.GetAsync();
Assert.Equal(actualData.Select(l => l.Code), expectedData.Select(l => l.Code));
return(true);
});
}
public async Task <bool> RemoveAllMembers()
{
var members = await GetClusterMembers();
if (!members.Any())
{
return(true);
}
var response = _client.PutAsync(SEEDS, "[]");
return(true);
}
/// <summary>
/// 创建Client节点树
/// </summary>
/// <returns></returns>
private static async Task CreateClientTree()
{
if (m_client != null)
{
//移除Client所有节点
await m_client.DeleteRangeAsync("Client/");
await m_client.PutAsync("Client/Client0", "OffLine");
await m_client.PutAsync("Client/Client1", "OffLine");
await m_client.PutAsync("Client/Client2", "OffLine");
}
}
public async Task WriteStateAsync(string grainType, GrainReference grainReference, IGrainState grainState)
{
var key = GetKeyName(grainType, grainReference);
try {
if (this.logger.IsEnabled(LogLevel.Trace))
{
this.logger.Trace((int)MorsteadEtcdProviderErrorCode.MorsteadEtcdProvider_Storage_Writing, "Writing: GrainType={0} Grainid={1} ETag={2} to Container={3}", grainType, grainReference, grainState.ETag, name);
}
await etcdClient.PutAsync(key, ConvertToStorageFormat(grainState.State)).ConfigureAwait(false);
if (this.logger.IsEnabled(LogLevel.Trace))
{
this.logger.Trace((int)MorsteadEtcdProviderErrorCode.MorsteadEtcdProvider_Storage_Written, "Written: GrainType={0} Grainid={1} ETag={2} to Container={3}", grainType, grainReference, grainState.ETag, name);
}
}
catch (Exception ex)
{
logger.Error((int)MorsteadEtcdProviderErrorCode.MorsteadEtcdProvider_WriteError,
string.Format("Error writing: GrainType={0} Grainid={1} ETag={2} to Container={3} Exception={4}", grainType, grainReference, grainState.ETag, name, ex.Message),
ex);
throw;
}
}
public async Task <Response> Set(FileConfiguration ocelotConfiguration)
{
var json = JsonConvert.SerializeObject(ocelotConfiguration, Formatting.Indented);
var result = await _etcdClient.PutAsync($"/{_configurationKey}", json);
_cache.AddAndDelete(_configurationKey, ocelotConfiguration, TimeSpan.FromSeconds(3), _configurationKey);
return(new OkResponse());
// return new ErrorResponse(new UnableToSetConfigInEtcdError($"Unable to set FileConfiguration in etcd, response status code from etcd was {result.StatusCode}"));
}
/// <summary>
/// 系统配置注册
/// </summary>
/// <param name="client">客户端</param>
/// <param name="sysName">系统名称</param>
/// <param name="registration">配置信息</param>
/// <returns></returns>
private static async Task AddConfigAsync(EtcdClient client, string sysName, AgentServiceRegistration registration)
{
string key = "/" + sysName + "/config";
string timeKey = "/" + sysName + "/Time/" + registration.Name + "/" + registration.ID;
var leasersp = await client.LeaseGrantAsync(new LeaseGrantRequest()
{
ID = 0, TTL = 10
});
var lockrsp = await client.LockAsync(new V3Lockpb.LockRequest()
{
Lease = leasersp.ID, Name = (key + "1").ToGoogleString()
});
var rsp = await client.GetAsync(key);
EtcdConfig config = new EtcdConfig();
if (rsp.Kvs.Count == 0)
{
var lst = new List <AgentServiceRegistration>
{
registration
};
config.Services = lst;
}
else
{
var val = JsonConvert.DeserializeObject <EtcdConfig>(rsp.Kvs[0].Value.FromGoogleString());
List <AgentServiceRegistration> lst = new List <AgentServiceRegistration>(val.Services);
lst.Add(registration);
config.Services = lst;
}
string cof = JsonConvert.SerializeObject(config);
await client.PutAsync(key, cof);
await client.PutAsync(timeKey, DateTime.Now.ToString("yyyy-MM-dd mm:HH:ss"));
await client.UnlockAsync(key + "1");
}
// This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
public void Configure(IApplicationBuilder app, IHostingEnvironment env, IApplicationLifetime lifetime)
{
if (env.IsDevelopment())
{
app.UseDeveloperExceptionPage();
}
IList <string> uriList = new List <string>();
var controllers = Assembly.GetExecutingAssembly().GetTypes()
.Where(type => typeof(ControllerBase).IsAssignableFrom(type));
Type routeType = typeof(RouteAttribute);
foreach (var item in controllers)
{
string routeName = string.Empty;
var route = item.CustomAttributes.Where(type => type.AttributeType.IsAssignableFrom(routeType));
if (route.Count() > 0)
{
routeName = route?.FirstOrDefault()?.ConstructorArguments?.FirstOrDefault().Value.ToString();
int inde = routeName.IndexOf("[");
routeName = routeName.Substring(0, inde);
}
string contName = item.Name.Replace("Controller", string.Empty);
uriList.Add($"{contName}#{routeName}{contName}");
}
string host = "127.0.0.1";
int port = 2379;
string putKey = "/test/{0}#{1}";
using (EtcdClient etcd = new EtcdClient(host, port))
{
foreach (var item in uriList)
{
string[] uridata = item.Split('#');
etcd.PutAsync(string.Format(putKey, uridata[0], uri.Authority).ToLower(), $"{uri.ToString()}{uridata[1]}");
}
}
lifetime.ApplicationStopped.Register(() =>
{
using (EtcdClient etcd = new EtcdClient(host, port))
{
foreach (var item in uriList)
{
string[] uridata = item.Split('#');
etcd.DeleteAsync(string.Format(putKey, uridata[0], uri.Authority).ToLower());
}
}
});
app.UseMvc();
}
public async Task ImHere()
{
var leaseGrantRequest = new LeaseGrantRequest
{
TTL = LeaseTtl
};
var leaseGrantResponse = await _client.LeaseGrantAsync(leaseGrantRequest);
_leaseId = leaseGrantResponse.ID;
await _client.PutAsync(new PutRequest
{
Lease = leaseGrantResponse.ID,
Key = _key,
Value = _broker
});
_timer = new Timer(LeaseKeepAlive, null, TimeSpan.Zero, TimeSpan.FromSeconds(5));
}
public async void CanDeserializeKvsFromRange()
{
JsonConvert.SerializeObject(new MorsteadEtcdBasedReminderEntry()
{
ETag = "ETag"
});
var client = new EtcdClient("http://localhost:2379");
await client.PutAsync("key/1", JsonConvert.SerializeObject(new MorsteadEtcdBasedReminderEntry()
{
ETag = "ETag"
}));
var s = await client.GetRangeValAsync("key/*");
foreach (var i in s)
{
}
}
private async Task UpdateBrokerForPartition(BrokersObject brokersObject, int brokerNumber, int partitionNumber, string producerTablePrefixKey)
{
var key = producerTablePrefixKey + partitionNumber;
var value = brokersObject.Name + brokerNumber;
await _client.PutAsync(key, value);
}
/// <inheritdoc/>
public async Task WriteAsync(T model, params string[] keys)
{
var key = GetKey(keys);
await _etcdClient.PutAsync(key, _dataSerializer.Serialize(model), _metadata);
}
/// <summary>
/// Add/update a configuration reocrd in the repository
/// </summary>
/// <param name="configurationItem">The configuration record to add or update</param>
/// <param name="force">Force a set (overwrite) even if configuraton item already exists with a different version</param>
public virtual async Task Set(TModel configurationItem, bool force = false)
{
if (configurationItem == null)
{
throw new ArgumentNullException(nameof(configurationItem));
}
//Set created timestamp for version 0
if (configurationItem.Version == 0 || force)
{
configurationItem.CreatedOn = DateTimeOffset.UtcNow;
}
//Otherwise set modified timestamp
else
{
configurationItem.ModifiedOn = DateTimeOffset.UtcNow;
}
//Create the etcd key for the configuration item
var etcdKey = CreateEtcdKey(configurationItem);
//Serialise configuration item as JSON to persist to etcd
var json = JsonConvert.SerializeObject(configurationItem, typeof(TModel), _jsonSerializerSettings);
//Ensure the repository is initialised before retreiving item
await _readyTask.ConfigureAwait(false);
//If we force an update then we just put the value without a check
if (force)
{
//Put the key/value into etcd
var setReponse = await _etcdClient.PutAsync(etcdKey, json).ConfigureAwait(false);
//Update the configuration item version
configurationItem.Version = setReponse.Header.Revision;
}
//If we do not force update we need to do a CAS (check and set) which will eliminate concurrency issues and accidental overwrites
else
{
//Create a transaction that checks the ModRevision is the same as the configuration item before performing the put operation
var transReq = new TxnRequest();
if (configurationItem.Version == 0)
{
transReq.Compare.Add(new Compare
{
Key = Google.Protobuf.ByteString.CopyFromUtf8(etcdKey),
Result = Compare.Types.CompareResult.Equal,
CreateRevision = configurationItem.Version,
Target = Compare.Types.CompareTarget.Create
});
}
else
{
transReq.Compare.Add(new Compare
{
Key = Google.Protobuf.ByteString.CopyFromUtf8(etcdKey),
Result = Compare.Types.CompareResult.Equal,
ModRevision = configurationItem.Version,
Target = Compare.Types.CompareTarget.Mod
});
}
transReq.Success.Add(new RequestOp
{
RequestPut = new PutRequest
{
Key = Google.Protobuf.ByteString.CopyFromUtf8(etcdKey),
Value = Google.Protobuf.ByteString.CopyFromUtf8(json)
}
});
//Execute transaction
var transResponse = await _etcdClient.TransactionAsync(transReq);
//Check the transaction succeeded
if (transResponse.Succeeded)
{
//Update the configuration item version
configurationItem.Version = transResponse.Responses[0].ResponsePut.Header.Revision;
}
else
{
throw new ArgumentException("Unable to set configuration item, either the specified item does not exist or the version specified was incorrect.");
}
}
}
/// <summary>
/// 注册服务
/// </summary>
/// <param name="client">客户端</param>
/// <param name="systemName">系统名称(默认：Agent)</param>
/// <param name="registration">注册信息</param>
/// <returns></returns>
public static async Task <bool> RegisterAsync(this EtcdClient client, AgentServiceRegistration registration, string systemName = "Agent")
{
try
{
// /系统/Services/srvname/srvid
ServiceEntry entry = new ServiceEntry()
{
Host = registration.Address,
Port = registration.Port,
Name = registration.Name,
Id = registration.ID,
Tags = registration.Tags,
Version = registration.Version
};
if (registration.Checks == null || registration.Checks.Length == 0)
{
registration.Checks = new AgentServiceCheck[1];
registration.Checks[0] = new AgentServiceCheck();
registration.Checks[0].Interval = new TimeSpan(0, 0, 5);
}
var val = JsonConvert.SerializeObject(entry);
string key = "/" + systemName + "/Services/" + entry.Name + "/" + entry.Id;
CancellationToken token = new CancellationToken();
if (!string.IsNullOrEmpty(Utiletcd.Sinlgeton.Password) || !string.IsNullOrEmpty(Utiletcd.Sinlgeton.Username))
{
await client.AuthenticateAsync(new AuthenticateRequest()
{
Name = Utiletcd.Sinlgeton.Username,
Password = Utiletcd.Sinlgeton.Password
});
}
//申请TTL的ID
var lease = await client.LeaseGrantAsync(new LeaseGrantRequest()
{
ID = 0, TTL = (long)registration.Checks[0].Interval.TotalSeconds
});
//加入节点
var rsp = await client.PutAsync(new PutRequest()
{
Key = key.ToGoogleString(), Value = val.ToGoogleString(), Lease = lease.ID
});
//保持激活
await client.LeaseKeepAlive(new LeaseKeepAliveRequest()
{
ID = lease.ID
}, Watch, token);
//添加配置
await AddConfigAsync(client, systemName, registration);
//服务加入更新列表
await Utiletcd.Sinlgeton.AddKeepAliveAsync(client, key, (long)registration.Checks[0].Interval.TotalSeconds, lease.ID);
Init(client, key);
return(true);
}catch (Exception ex)
{
return(false);
}
}
public async Task PutAsync(string key, string value)
{
await _etcdClient.PutAsync(key, value);
}
