/// <summary>
/// Constructor with passed response delegate
/// </summary>
/// <param name="_rd">Function name of response delegate</param>
/// <param name="_dd">Function name of done delegate</param>
public SRT(ResponseDelegate _rd, DoneDelegate _dd)
{
InitializeComponent();
ResetAll();
_responseDelegate = _rd;
_doneDelegate = _dd;
}
/// <summary>
/// Constructor with passed delegates
/// </summary>
/// <param name="_dd">Name of Done Delegate</param>
/// <param name="_rd">Name of Response Delegate</param>
public WI(DoneDelegate _dd, ResponseDelegate _rd)
{
InitializeComponent();
ResetAll();
_doneDelegate = _dd;
_responseDelegate = _rd;
}
private async UniTaskVoid OnRequestSelectCharacter(ResponseHandlerData responseHandler, AckResponseCode responseCode, ResponseSelectCharacterMessage response, string characterId, ResponseDelegate <ResponseSelectCharacterMessage> callback)
{
await UniTask.Yield();
if (callback != null)
{
callback.Invoke(responseHandler, responseCode, response);
}
GameInstance.SelectedCharacterId = string.Empty;
if (responseCode == AckResponseCode.Success)
{
GameInstance.SelectedCharacterId = characterId;
}
}
private async UniTaskVoid OnRequestUserLogout(ResponseHandlerData responseHandler, AckResponseCode responseCode, INetSerializable response, ResponseDelegate <INetSerializable> callback)
{
await UniTask.Yield();
if (callback != null)
{
callback.Invoke(responseHandler, responseCode, response);
}
GameInstance.UserId = string.Empty;
GameInstance.UserToken = string.Empty;
GameInstance.SelectedCharacterId = string.Empty;
}
public void RequestDeleteCharacter(string characterId, ResponseDelegate <ResponseDeleteCharacterMessage> callback)
{
CentralNetworkManager.RequestDeleteCharacter(characterId, callback);
}
public void RequestCharacters(ResponseDelegate <ResponseCharactersMessage> callback)
{
CentralNetworkManager.RequestCharacters(callback);
}
public void RequestUserLogout(ResponseDelegate <INetSerializable> callback)
{
CentralNetworkManager.RequestUserLogout((responseHandler, responseCode, response) => OnRequestUserLogout(responseHandler, responseCode, response, callback).Forget());
}
public void Request(ResponseDelegate aResponseDelegate)
{
FXmlResponse = (XmlResponseLogoutUser)aResponseDelegate(FXmlMessage, XmlResponseFactory.LogoutUser);
}
public void Request(ResponseDelegate aResponseDelegate)
{
FXmlResponse = (XmlResponseGetDocPlacement)aResponseDelegate(FXmlMessage, XmlResponseFactory.GetDocPlacement);
}
static public void Yield(uint msgid, CallAttr attr, ResponseDelegate d)
{
dispatchers[msgid] = new YieldContext {
d = d, timeout_at = Time.time + attr.timeout
};
}
void Dispatch(object[] req, CallAttr attr, uint msgid, ResponseDelegate d)
{
WriteStream(req);
TransportManager.Yield(msgid, attr, d);
}
public bool RequestUserRegister(string username, string password, string email, ResponseDelegate <ResponseUserRegisterMessage> callback)
{
return(ClientSendRequest(MMORequestTypes.RequestUserRegister, new RequestUserRegisterMessage()
{
username = username,
password = password,
email = email,
}, responseDelegate: callback));
}
public async Task UpdateFromClient(SyncConfiguration conf)
{
Guid newId = Guid.NewGuid();
var insertRowScript =
$@"INSERT INTO [ServiceTickets] ([ServiceTicketID], [Title], [Description], [StatusValue], [EscalationLevel], [Opened], [Closed], [CustomerID])
VALUES ('{newId.ToString()}', 'Insert One Row in SQLite client', 'Description Insert One Row', 1, 0, datetime('now'), NULL, 1)";
using (var sqlConnection = new SQLiteConnection(fixture.ClientSQLiteConnectionString))
{
using (var sqlCmd = new SQLiteCommand(insertRowScript, sqlConnection))
{
sqlConnection.Open();
sqlCmd.ExecuteNonQuery();
sqlConnection.Close();
}
}
using (var server = new KestrellTestServer())
{
var serverHandler = new RequestDelegate(async context =>
{
conf.Tables = fixture.Tables;
serverProvider.SetConfiguration(conf);
proxyServerProvider.SerializationFormat = conf.SerializationFormat;
await proxyServerProvider.HandleRequestAsync(context);
});
var clientHandler = new ResponseDelegate(async(serviceUri) =>
{
proxyClientProvider.ServiceUri = new Uri(serviceUri);
proxyClientProvider.SerializationFormat = conf.SerializationFormat;
var session = await agent.SynchronizeAsync();
Assert.Equal(0, session.TotalChangesDownloaded);
Assert.Equal(1, session.TotalChangesUploaded);
});
await server.Run(serverHandler, clientHandler);
}
var updateRowScript =
$@" Update [ServiceTickets] Set [Title] = 'Updated from SQLite Client side !' Where ServiceTicketId = '{newId.ToString()}'";
using (var sqlConnection = new SQLiteConnection(fixture.ClientSQLiteConnectionString))
{
using (var sqlCmd = new SQLiteCommand(updateRowScript, sqlConnection))
{
sqlConnection.Open();
sqlCmd.ExecuteNonQuery();
sqlConnection.Close();
}
}
using (var server = new KestrellTestServer())
{
var serverHandler = new RequestDelegate(async context =>
{
conf.Tables = fixture.Tables;
serverProvider.SetConfiguration(conf);
proxyServerProvider.SerializationFormat = conf.SerializationFormat;
await proxyServerProvider.HandleRequestAsync(context);
});
var clientHandler = new ResponseDelegate(async(serviceUri) =>
{
proxyClientProvider.ServiceUri = new Uri(serviceUri);
proxyClientProvider.SerializationFormat = conf.SerializationFormat;
var session = await agent.SynchronizeAsync();
Assert.Equal(0, session.TotalChangesDownloaded);
Assert.Equal(1, session.TotalChangesUploaded);
});
await server.Run(serverHandler, clientHandler);
}
}
public bool SendRequest <TRequest>(long connectionId, ushort requestType, TRequest request, ResponseDelegate <INetSerializable> responseDelegate = null, int millisecondsTimeout = 30000, SerializerDelegate extraRequestSerializer = null)
where TRequest : INetSerializable, new()
{
if (!CreateAndWriteRequest(Writer, requestType, request, responseDelegate, millisecondsTimeout, extraRequestSerializer))
{
return(false);
}
SendMessage(connectionId, 0, DeliveryMethod.ReliableUnordered, Writer);
return(true);
}
public void DoRequest(string url, RequestDelegate prepareRq, ResponseDelegate handleResp)
{
HttpWebRequest wrq = (HttpWebRequest) WebRequest.Create(url);
prepareRq(wrq);
HttpWebResponse resp = (HttpWebResponse) wrq.GetResponse();
}
public void RequestUserRegister(string username, string password, ResponseDelegate <ResponseUserRegisterMessage> callback)
{
centralNetworkManager.RequestUserRegister(username, password, callback);
}
public void Request(ResponseDelegate aResponseDelegate)
{
FXmlResponse = (XmlResponseRegisterPlacement)aResponseDelegate(FXmlMessage, XmlResponseFactory.RegisterPlacement);
}
public async Task ConflictUpdateUpdateClientWins(SyncConfiguration conf)
{
var id = Guid.NewGuid().ToString();
using (var sqlConnection = new SqlConnection(fixture.Client1ConnectionString))
{
var script = $@"INSERT [ServiceTickets]
([ServiceTicketID], [Title], [Description], [StatusValue], [EscalationLevel], [Opened], [Closed], [CustomerID])
VALUES
(N'{id}', N'Line for conflict', N'Description client', 1, 0, getdate(), NULL, 1)";
using (var sqlCmd = new SqlCommand(script, sqlConnection))
{
sqlConnection.Open();
sqlCmd.ExecuteNonQuery();
sqlConnection.Close();
}
}
using (var server = new KestrellTestServer())
{
var serverHandler = new RequestDelegate(async context =>
{
conf.Tables = fixture.Tables;
serverProvider.SetConfiguration(conf);
proxyServerProvider.SerializationFormat = conf.SerializationFormat;
await proxyServerProvider.HandleRequestAsync(context);
});
var clientHandler = new ResponseDelegate(async(serviceUri) =>
{
proxyClientProvider.ServiceUri = new Uri(serviceUri);
proxyClientProvider.SerializationFormat = conf.SerializationFormat;
var session = await agent.SynchronizeAsync();
// check statistics
Assert.Equal(0, session.TotalChangesDownloaded);
Assert.Equal(1, session.TotalChangesUploaded);
Assert.Equal(0, session.TotalSyncConflicts);
});
await server.Run(serverHandler, clientHandler);
}
using (var sqlConnection = new SqlConnection(fixture.Client1ConnectionString))
{
var script = $@"Update [ServiceTickets]
Set Title = 'Updated from Client'
Where ServiceTicketId = '{id}'";
using (var sqlCmd = new SqlCommand(script, sqlConnection))
{
sqlConnection.Open();
sqlCmd.ExecuteNonQuery();
sqlConnection.Close();
}
}
using (var sqlConnection = new SqlConnection(fixture.ServerConnectionString))
{
var script = $@"Update [ServiceTickets]
Set Title = 'Updated from Server'
Where ServiceTicketId = '{id}'";
using (var sqlCmd = new SqlCommand(script, sqlConnection))
{
sqlConnection.Open();
sqlCmd.ExecuteNonQuery();
sqlConnection.Close();
}
}
using (var server = new KestrellTestServer())
{
var serverHandler = new RequestDelegate(async context =>
{
conf.Tables = fixture.Tables;
serverProvider.SetConfiguration(conf);
proxyServerProvider.SerializationFormat = conf.SerializationFormat;
// Since we move to server side, it's server to handle errors
serverProvider.ApplyChangedFailed += (s, args) =>
{
args.Action = ApplyAction.RetryWithForceWrite;
};
await proxyServerProvider.HandleRequestAsync(context);
});
var clientHandler = new ResponseDelegate(async(serviceUri) =>
{
proxyClientProvider.ServiceUri = new Uri(serviceUri);
proxyClientProvider.SerializationFormat = conf.SerializationFormat;
SyncContext session = null;
await Assert.RaisesAsync <ApplyChangeFailedEventArgs>(
h => serverProvider.ApplyChangedFailed += h,
h => serverProvider.ApplyChangedFailed -= h, async() =>
{
session = await agent.SynchronizeAsync();
});
// check statistics
Assert.Equal(0, session.TotalChangesDownloaded);
Assert.Equal(1, session.TotalChangesUploaded);
Assert.Equal(1, session.TotalSyncConflicts);
});
await server.Run(serverHandler, clientHandler);
}
string expectedRes = string.Empty;
using (var sqlConnection = new SqlConnection(fixture.ServerConnectionString))
{
var script = $@"Select Title from [ServiceTickets] Where ServiceTicketID='{id}'";
using (var sqlCmd = new SqlCommand(script, sqlConnection))
{
sqlConnection.Open();
expectedRes = sqlCmd.ExecuteScalar() as string;
sqlConnection.Close();
}
}
// check good title on client
Assert.Equal("Updated from Client", expectedRes);
}
public async Task ConflictInsertInsertConfigurationClientWins(SyncConfiguration conf)
{
Guid id = Guid.NewGuid();
using (var sqlConnection = new SqlConnection(fixture.Client1ConnectionString))
{
var script = $@"INSERT [ServiceTickets]
([ServiceTicketID], [Title], [Description], [StatusValue], [EscalationLevel], [Opened], [Closed], [CustomerID])
VALUES
(N'{id.ToString()}', N'Conflict Line Client', N'Description client', 1, 0, getdate(), NULL, 1)";
using (var sqlCmd = new SqlCommand(script, sqlConnection))
{
sqlConnection.Open();
sqlCmd.ExecuteNonQuery();
sqlConnection.Close();
}
}
using (var sqlConnection = new SqlConnection(fixture.ServerConnectionString))
{
var script = $@"INSERT [ServiceTickets]
([ServiceTicketID], [Title], [Description], [StatusValue], [EscalationLevel], [Opened], [Closed], [CustomerID])
VALUES
(N'{id.ToString()}', N'Conflict Line Server', N'Description client', 1, 0, getdate(), NULL, 1)";
using (var sqlCmd = new SqlCommand(script, sqlConnection))
{
sqlConnection.Open();
sqlCmd.ExecuteNonQuery();
sqlConnection.Close();
}
}
using (var server = new KestrellTestServer())
{
var serverHandler = new RequestDelegate(async context =>
{
conf.Tables = fixture.Tables;
conf.ConflictResolutionPolicy = ConflictResolutionPolicy.ClientWins;
serverProvider.SetConfiguration(conf);
proxyServerProvider.SerializationFormat = conf.SerializationFormat;
await proxyServerProvider.HandleRequestAsync(context);
});
var clientHandler = new ResponseDelegate(async(serviceUri) =>
{
proxyClientProvider.ServiceUri = new Uri(serviceUri);
proxyClientProvider.SerializationFormat = conf.SerializationFormat;
var session = await agent.SynchronizeAsync();
// check statistics
Assert.Equal(0, session.TotalChangesDownloaded);
Assert.Equal(1, session.TotalChangesUploaded);
Assert.Equal(1, session.TotalSyncConflicts);
});
await server.Run(serverHandler, clientHandler);
}
string expectedRes = string.Empty;
using (var sqlConnection = new SqlConnection(fixture.ServerConnectionString))
{
var script = $@"Select Title from [ServiceTickets] Where ServiceTicketID='{id.ToString()}'";
using (var sqlCmd = new SqlCommand(script, sqlConnection))
{
sqlConnection.Open();
expectedRes = sqlCmd.ExecuteScalar() as string;
sqlConnection.Close();
}
}
// check good title on client
Assert.Equal("Conflict Line Client", expectedRes);
}
public Coroutine CreateMatch(string matchName, uint matchSize, bool matchAdvertise, string matchPassword, ResponseDelegate <CreateMatchResponse> callback)
{
CreateMatchRequest req = new CreateMatchRequest {
name = matchName,
size = matchSize,
advertise = matchAdvertise,
password = matchPassword
};
return(this.CreateMatch(req, callback));
}
public bool RequestCharacters(ResponseDelegate <ResponseCharactersMessage> callback)
{
return(ClientSendRequest(MMORequestTypes.RequestCharacters, EmptyMessage.Value, responseDelegate: callback));
}
public void RequestValidateAccessToken(string userId, string accessToken, ResponseDelegate <ResponseValidateAccessTokenMessage> callback)
{
CentralNetworkManager.RequestValidateAccessToken(userId, accessToken, (responseHandler, responseCode, response) => OnRequestValidateAccessToken(responseHandler, responseCode, response, callback).Forget());
}
public void Request(ResponseDelegate aResponseDelegate)
{
FXmlResponse = (XmlResponseGetExpiredData)aResponseDelegate(FXmlMessage, XmlResponseFactory.GetExpiredData);
}
public void RequestCreateCharacter(PlayerCharacterData characterData, ResponseDelegate <ResponseCreateCharacterMessage> callback)
{
CentralNetworkManager.RequestCreateCharacter(characterData, callback);
}
public bool RequestUserLogout(ResponseDelegate <INetSerializable> callback)
{
return(ClientSendRequest(MMORequestTypes.RequestUserLogout, EmptyMessage.Value, responseDelegate: callback));
}
public void RequestSelectCharacter(string characterId, ResponseDelegate <ResponseSelectCharacterMessage> callback)
{
CentralNetworkManager.RequestSelectCharacter(characterId, (responseHandler, responseCode, response) => OnRequestSelectCharacter(responseHandler, responseCode, response, characterId, callback).Forget());
}
public void Request(ResponseDelegate aResponseDelegate)
{
FXmlResponse = (XmlResponseLogoutUser)aResponseDelegate(FXmlMessage, XmlResponseFactory.LogoutUser);
}
private async UniTaskVoid OnRequestValidateAccessToken(ResponseHandlerData responseHandler, AckResponseCode responseCode, ResponseValidateAccessTokenMessage response, ResponseDelegate <ResponseValidateAccessTokenMessage> callback)
{
await UniTask.Yield();
if (callback != null)
{
callback.Invoke(responseHandler, responseCode, response);
}
GameInstance.UserId = string.Empty;
GameInstance.UserToken = string.Empty;
if (responseCode == AckResponseCode.Success)
{
GameInstance.UserId = response.userId;
GameInstance.UserToken = response.accessToken;
}
}
public void RequestUserLogout(ResponseDelegate callback)
{
centralNetworkManager.RequestUserLogout((responseHandler, responseCode, response) => OnRequestUserLogout(responseHandler, responseCode, response, callback));
}
public async Task <ProviderRun> RunAsync(CoreProvider serverProvider,
ProviderFixture <CoreProvider> serverFixture,
string scopeName = null, string[] tables = null,
SyncConfiguration conf = null,
bool reuseAgent = true)
{
// server proxy
var proxyServerProvider = new WebProxyServerProvider(serverProvider);
var proxyClientProvider = new WebProxyClientProvider();
var syncTables = tables ?? serverFixture.Tables;
// local test, through tcp
if (this.NetworkType == NetworkType.Tcp)
{
// create agent
if (this.Agent == null || !reuseAgent)
{
this.Agent = new SyncAgent(this.ClientProvider, serverProvider, syncTables);
}
// copy conf settings
if (conf != null)
{
serverFixture.CopyConfiguration(this.Agent.Configuration, conf);
}
// Add Filers
if (serverFixture.Filters != null && serverFixture.Filters.Count > 0)
{
serverFixture.Filters.ForEach(f =>
{
if (!this.Agent.Configuration.Filters.Contains(f))
{
this.Agent.Configuration.Filters.Add(f);
}
});
}
// Add Filers values
if (serverFixture.FilterParameters != null && serverFixture.FilterParameters.Count > 0)
{
foreach (var syncParam in serverFixture.FilterParameters)
{
if (!this.Agent.Parameters.Contains(syncParam))
{
this.Agent.Parameters.Add(syncParam);
}
}
}
// sync
try
{
this.BeginRun?.Invoke(this.Agent.RemoteProvider);
this.Results = await this.Agent.SynchronizeAsync();
this.EndRun?.Invoke(this.Agent.RemoteProvider);
}
catch (Exception ex)
{
this.Exception = ex;
Console.WriteLine(ex);
}
}
// -----------------------------------------------------------------------
// HTTP
// -----------------------------------------------------------------------
// tests through http proxy
if (this.NetworkType == NetworkType.Http)
{
// client handler
using (var server = new KestrellTestServer())
{
// server handler
var serverHandler = new RequestDelegate(async context =>
{
var syncConfiguration = new SyncConfiguration(syncTables);// set proxy conf
// copy conf settings
if (conf != null)
{
serverFixture.CopyConfiguration(syncConfiguration, conf);
}
// set proxy conf
proxyServerProvider.Configuration = syncConfiguration;
// test if <> directory name works
proxyServerProvider.Options = new SyncOptions();
proxyServerProvider.Options.BatchDirectory = Path.Combine(SyncOptions.GetDefaultUserBatchDiretory(), "server");
// Add Filers
if (serverFixture.Filters != null && serverFixture.Filters.Count > 0)
{
serverFixture.Filters.ForEach(f =>
{
if (!proxyServerProvider.Configuration.Filters.Contains(f))
{
proxyServerProvider.Configuration.Filters.Add(f);
}
});
}
// sync
try
{
this.BeginRun?.Invoke(proxyServerProvider.LocalProvider);
await proxyServerProvider.HandleRequestAsync(context);
this.EndRun?.Invoke(proxyServerProvider.LocalProvider);
}
catch (Exception ew)
{
Console.WriteLine(ew);
}
});
var clientHandler = new ResponseDelegate(async(serviceUri) =>
{
// create agent
if (this.Agent == null || !reuseAgent)
{
this.Agent = new SyncAgent(this.ClientProvider, proxyClientProvider);
}
if (serverFixture.FilterParameters != null && serverFixture.FilterParameters.Count > 0)
{
foreach (var syncParam in serverFixture.FilterParameters)
{
if (!this.Agent.Parameters.Contains(syncParam))
{
this.Agent.Parameters.Add(syncParam);
}
}
}
((WebProxyClientProvider)this.Agent.RemoteProvider).ServiceUri = new Uri(serviceUri);
try
{
this.Results = await this.Agent.SynchronizeAsync();
}
catch (Exception ew)
{
this.Exception = ew;
Console.WriteLine(ew);
}
});
await server.Run(serverHandler, clientHandler);
}
}
return(this);
}
public void RequestCharacters(ResponseDelegate callback)
{
centralNetworkManager.RequestCharacters(callback);
}
public void RequestUserLogin(string username, string password, ResponseDelegate <ResponseUserLoginMessage> callback)
{
centralNetworkManager.RequestUserLogin(username, password, (responseHandler, responseCode, response) => OnRequestUserLogin(responseHandler, responseCode, response, callback));
}
public void RequestSelectCharacter(string characterId, ResponseDelegate callback)
{
centralNetworkManager.RequestSelectCharacter(characterId, (responseHandler, responseCode, response) => OnRequestSelectCharacter(responseHandler, responseCode, response, characterId, callback));
}
public void Request(ResponseDelegate aResponseDelegate)
{
FXmlResponse = (XmlResponseGetBinContent)aResponseDelegate(FXmlMessage, XmlResponseFactory.GetBinContent);
}
private void OnRequestUserLogout(ResponseHandlerData responseHandler, AckResponseCode responseCode, INetSerializable response, ResponseDelegate callback)
{
if (callback != null)
{
callback.Invoke(responseHandler, responseCode, response);
}
UserId = string.Empty;
AccessToken = string.Empty;
SelectCharacterId = string.Empty;
}
public void Request(RequestType type, ResponseDelegate onResponse)
{
if (!SteamService.IsInitialized) return;
if (_responder == null)
{
_responder = new ISteamMatchmakingServerListResponse(OnResponded, OnFailedToRespond, OnRefreshComplete);
}
CancelRequest();
_onResponse = onResponse;
var filters = _filters.ToArray();
uint filterCount = (uint)_filters.Count;
var appid = SteamService.SteamAppid;
switch (type)
{
case RequestType.Favourites:
_handle = SteamMatchmakingServers.RequestFavoritesServerList(appid, filters, filterCount, _responder);
break;
case RequestType.Friends:
_handle = SteamMatchmakingServers.RequestFriendsServerList(appid, filters, filterCount, _responder);
break;
case RequestType.History:
_handle = SteamMatchmakingServers.RequestHistoryServerList(appid, filters, filterCount, _responder);
break;
case RequestType.Internet:
_handle = SteamMatchmakingServers.RequestInternetServerList(appid, filters, filterCount, _responder);
break;
case RequestType.LAN:
_handle = SteamMatchmakingServers.RequestLANServerList(appid, _responder);
break;
}
}
private void OnRequestValidateAccessToken(ResponseHandlerData responseHandler, AckResponseCode responseCode, INetSerializable response, ResponseDelegate callback)
{
if (callback != null)
{
callback.Invoke(responseHandler, responseCode, response);
}
UserId = string.Empty;
AccessToken = string.Empty;
if (responseCode == AckResponseCode.Success)
{
ResponseValidateAccessTokenMessage castedResponse = response as ResponseValidateAccessTokenMessage;
UserId = castedResponse.userId;
AccessToken = castedResponse.accessToken;
}
}
public UserEventArgs(string originIdentifier, ResponseDelegate responseHandler)
{
OriginIdentifier = originIdentifier;
_responseHandler = responseHandler;
}
private void OnRequestSelectCharacter(ResponseHandlerData responseHandler, AckResponseCode responseCode, INetSerializable response, string characterId, ResponseDelegate callback)
{
if (callback != null)
{
callback.Invoke(responseHandler, responseCode, response);
}
SelectCharacterId = string.Empty;
if (responseCode == AckResponseCode.Success)
{
SelectCharacterId = characterId;
}
}
private static void GetRequest(string url, ResponseDelegate callback)
{
var initialRequest = HttpWebRequest.Create(url);
var initialResult = (IAsyncResult)initialRequest.BeginGetResponse((IAsyncResult result) => {
var request = (HttpWebRequest)result.AsyncState;
var response = request.EndGetResponse(result);
using (var stream = response.GetResponseStream())
using (var reader = new StreamReader(stream)) {
callback(JObject.Parse(reader.ReadToEnd()));
}
}, initialRequest);
}
private IEnumerator ProcessMatchResponse <JSONRESPONSE>(WWW client, ResponseDelegate <JSONRESPONSE> callback) where JSONRESPONSE : Response, new()
{
return(new < ProcessMatchResponse > c__Iterator0 <JSONRESPONSE> {
client = client, callback = callback, <$> client = client, <$> callback = callback
});
