static int _m_Connect(RealStatePtr L)
{
try {
ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
WsGame __cl_gen_to_be_invoked = (WsGame)translator.FastGetCSObj(L, 1);
{
string url = LuaAPI.lua_tostring(L, 2);
ConnectCallback callback = translator.GetDelegate <ConnectCallback>(L, 3);
OnMessageCallback msgHandler = translator.GetDelegate <OnMessageCallback>(L, 4);
__cl_gen_to_be_invoked.Connect(url, callback, msgHandler);
return(0);
}
} catch (System.Exception __gen_e) {
return(LuaAPI.luaL_error(L, "c# exception:" + __gen_e));
}
}
public Exception DeltaUploadProject(string fileName, string projectId,
OnProgressCallback progressCb, OnMessageCallback messageCallback, OnSuccessCallback <CosResult> successCb,
OnFailedCallback failedCb)
{
var filePath = Path.GetFullPath(fileName);
if (!File.Exists(filePath))
{
failedCb(
new CosClientException(COS_STATUS.CLIENT_ERR,
string.Format(COS_MSG.ERR_CLIENT_TARGET_NOT_EXIST, fileName)),
new CosServerException(COS_STATUS.CLIENT_ERR, COS_MSG.ERR_CLIENT)
);
}
var fileKey = $"{projectId}/{Path.GetFileName(fileName)}";
if (CheckFileExists(sourceBucket, fileKey))
{
successCb(CreateTaskResult(COS_STATUS.SKIP,
string.Format(COS_MSG.INFO_TARGET_EXIST_ON_SERVER, fileName)));
return(null);
}
if (CheckFileExists(deltaBucket, $"{projectId}/{BASE_META}"))
{
_DeltaUpdateProject(filePath, projectId, progressCb, messageCallback, successCb, failedCb);
}
else
{
_InitProject(filePath, projectId, progressCb, messageCallback, successCb, failedCb);
}
return(new Exception());
}
void logger_OnLogMessage(string message)
{
if (dataGridView_log.InvokeRequired)
{
OnMessageCallback d = new OnMessageCallback(logger_OnLogMessage);
this.Invoke(d, new object[] { message });
}
else
{
dataGridView_log.Rows.Add(message);
dataGridView_log.FirstDisplayedScrollingRowIndex = dataGridView_log.RowCount - 1;
//listViewLog.BeginUpdate();
//ListViewItem item = dataGridView_log.Items.Add(message);
if (message.Contains(" Warning:"))
{
dataGridView_log.Rows[dataGridView_log.RowCount - 1].Cells[0].Style.ForeColor = Color.Blue;
}
else if (message.Contains(" Error:"))
{
dataGridView_log.Rows[dataGridView_log.RowCount - 1].Cells[0].Style.ForeColor = Color.Red;
}
//item.ForeColor = Color.Red;
//item.ForeColor = Color.Blue;
//item.EnsureVisible();
//listViewLog.EndUpdate();
}
}
public ISubscription Subscribe(string topic, OnMessageCallback onMessage)
{
var subscription = CreateEmptySubscription();
subscription.SubscribeTopic(topic);
subscription.OnMessage += onMessage;
return(subscription);
}
public void AsyncUploadProject(string fileName, string projectId,
OnProgressCallback progressCb, OnMessageCallback messageCallback, OnSuccessCallback <CosResult> successCb,
OnFailedCallback failedCb)
{
Func <string, string, OnProgressCallback, OnMessageCallback, OnSuccessCallback <CosResult>, OnFailedCallback,
Exception> fun = DeltaUploadProject;
fun.BeginInvoke(fileName, projectId, progressCb, messageCallback, successCb, failedCb,
ar => { Console.WriteLine(ar.AsyncState); }, fun);
}
/// <summary>
/// Call back method to handle incoming m_data.
/// </summary>
/// <param name="ar">Status of an asynchronous operation.</param>
private void OnDataReceived(IAsyncResult ar)
{
int bytesRead = 0;
byte [] readData = null;
// Retrieve the state object and the handler socket
// from the async state object.
SocketPacket theSockId = ar.AsyncState as SocketPacket;
if ((theSockId == null) || (theSockId.Socket == null))
{
return;
}
try
{
// Read m_data from the client socket.
bytesRead = theSockId.Socket.EndReceiveFrom(ar, ref _remoteEndPoint);
if (bytesRead > 0)
{
readData = theSockId.GetBufferBytes(bytesRead);
}
WaitForData();
}
catch (ObjectDisposedException)
{
Debug.WriteLine("OnDataReceived: Socket has been closed");
}
catch (SocketException exc)
{
Debug.WriteLine("Error receiving m_data: " + exc.ToString());
// If this is this is a connection socket then
// re-use it
if (_connectionless == false)
{
WaitForConnection();
}
}
if (readData != null)
{
OnMessageCallback msgCallback = _onMessage;
// Processing after restarting another recieve call
// just to speed things up
if (msgCallback != null)
{
msgCallback(readData);
}
}
}
public void Register(OnConnectCallback onconnect, OnCloseCallback onclose, OnMessageCallback onmessage, LogType log = null)
{
this.onconnect = onconnect;
this.onclose = onclose;
this.onmessage = onmessage;
this.log = log;
if (this.log == null)
{
this.log = Console.WriteLine;
}
}
public void UnregisterForTopics(OnMessageCallback cb, List <string> topics)
{
lock (callbacksLocker) {
foreach (var topic in topics)
{
if (callbacks.ContainsKey(topic))
{
callbacks[topic].Remove(cb);
}
}
}
}
void logger_OnLogMessage(string message)
{
if (listView_Log.InvokeRequired)
{
OnMessageCallback d = new OnMessageCallback(logger_OnLogMessage);
this.Invoke(d, new object[] { message });
}
else
{
listView_Log.BeginUpdate();
ListViewItem item = listView_Log.Items.Add(message);
item.EnsureVisible();
listView_Log.EndUpdate();
}
}
public void UploadProject(string fileName, string projectId,
OnProgressCallback progressCb, OnMessageCallback messageCallback, OnSuccessCallback <CosResult> successCb,
OnFailedCallback failedCb)
{
var filePath = Path.GetFullPath(fileName);
var fileKey = $"{projectId}/{Path.GetFileName(fileName)}";
if (CheckFileExists(sourceBucket, fileKey))
{
successCb(CreateTaskResult(COS_STATUS.SKIP,
string.Format(COS_MSG.INFO_TARGET_EXIST_ON_SERVER, fileName)));
return;
}
_InitProject(filePath, projectId, progressCb, messageCallback,
successCb, failedCb);
}
public void Connect(string url, ConnectCallback callback, OnMessageCallback msgHandler)
{
if (this._ws != null)
{
this._callback = null;
this._ws.Close();
}
this._callback = callback;
this._msgCallback = msgHandler;
_ws = new WebSocket(url);
_ws.OnOpen += OnOpen;
_ws.OnMessage += OnMessage;
_ws.OnError += OnError;
_ws.OnClose += OnClose;
_ws.ConnectAsync();
}
private void _InitProject(string filePath, string projectId,
OnProgressCallback progressCb, OnMessageCallback messageCallback, OnSuccessCallback <CosResult> successCb,
OnFailedCallback failedCb)
{
var localDir = Path.GetDirectoryName(filePath);
var fileKey = $"{projectId}/{Path.GetFileName(filePath)}";
var signatureKey = $"{fileKey}{SIG_SUFFIX}";
var signaturePath = $"{filePath}{SIG_SUFFIX}";
var baseMetaKey = $"{projectId}/{BASE_META}";
var baseMetaPath = $"{localDir}/{BASE_META}";
clearOldFiles(baseMetaPath, signaturePath);
AutoResetEvent signatureEvent = new AutoResetEvent(false);
AutoResetEvent baseMetaEvent = new AutoResetEvent(false);
messageCallback(COS_MSG.TITLE_UPLOADING_PROJECT,
string.Format(COS_MSG.INFO_UPLOADING_PROJECT, fileKey));
UploadFile(sourceBucket, fileKey, filePath, progressCb,
delegate(CosResult result1)
{
signatureEvent.WaitOne();
messageCallback(COS_MSG.TITLE_UPLOADING_SIG_FILE,
string.Format(COS_MSG.INFO_UPLOADING_SIG_FILE, signatureKey));
UploadFile(deltaBucket, signatureKey, signaturePath, progressCb,
delegate(CosResult result)
{
baseMetaEvent.WaitOne();
messageCallback(COS_MSG.TITLE_UPLOADING_META_FILE,
string.Format(COS_MSG.INFO_UPLOADING_META_FILE, baseMetaKey));
UploadFile(deltaBucket, baseMetaKey, baseMetaPath, progressCb,
delegate(CosResult cosResult)
{
clearOldFiles(baseMetaPath, signaturePath);
successCb(
CreateTaskResult(COS_STATUS.OK,
string.Format(COS_MSG.INFO_INIT_SUCCESS, filePath, projectId)));
}, failedCb);
}, failedCb);
}, failedCb);
AsyncCreateSignature(filePath, signaturePath, () => { signatureEvent.Set(); });
AsyncCreateBaseMeta(filePath, fileKey, signatureKey, projectId, baseMetaPath,
() => { baseMetaEvent.Set(); });
}
public void RegisterForTopics(OnMessageCallback cb, List <string> topics)
{
lock (callbacksLocker) {
foreach (var topic in topics)
{
if (callbacks.ContainsKey(topic))
{
callbacks[topic].Add(cb);
}
else
{
callbacks[topic] = new List <OnMessageCallback>()
{
cb
};
}
}
}
}
public void OnMessage(IMessage message)
{
// InvokeRequired required compares the thread ID of the
// calling thread to the thread ID of the creating thread.
// If these threads are different, it returns true.
if (this.rtxtMsgRcv.InvokeRequired)
{
OnMessageCallback d = new OnMessageCallback(OnMessage);
this.Invoke(d, new object[] { message });
}
else
{
try
{
ITextMessage msg = (ITextMessage)message;
string txt = msg.Text;
rtxtMsgRcv.AppendText("Message Received " + timeStamp(DateTime.Now) + ": " + txt + "\n");
}
catch (Exception e)
{
MessageBox.Show("Exception receiving message: " + "\n" + e.Message.ToString());
}
}
}
public void OnMessage(IMessage message)
{
// InvokeRequired required compares the thread ID of the
// calling thread to the thread ID of the creating thread.
// If these threads are different, it returns true.
if (this.tboxReceivedMessage.InvokeRequired)
{
OnMessageCallback d = new OnMessageCallback(OnMessage);
this.Invoke(d, new object[] { message });
}
else
{
try
{
ITextMessage msg = (ITextMessage)message;
string txt = msg.Text;
tboxReceivedMessage.AppendText("Message Received " + timeStamp(DateTime.Now) + ": " + txt + "\n");
}
catch (Exception e)
{
MessageBox.Show("Exception receiving message: " + "\n" + e.Message.ToString());
}
}
}
public void SetMessageHandler(OnMessageCallback func)
{
onMessageCallback = func;
}
internal static extern void _SetOnMessage(OnMessageCallback callback);
internal static extern void SetOnMessageDelegate(OnMessageCallback callback);
[DllImport("__Internal")] public static extern int WebSocketSetOnMessage(OnMessageCallback Callback);
public void AddMessageCallback(OnMessageCallback callback)
{
messageCallback += callback;
}
public void AddGuildCreateCallback(OnMessageCallback callback)
{
guildCreateCallback += callback;
}
public static extern void WebSocketSetOnMessage(OnMessageCallback callback);
private void _DeltaUpdateProject(string filePath, string projectId,
OnProgressCallback progressCb, OnMessageCallback messageCb, OnSuccessCallback <CosResult> successCb,
OnFailedCallback failedCb)
{
var localDir = Path.GetDirectoryName(filePath);
var fileName = Path.GetFileName(filePath);
var fileKey = $"{projectId}/{fileName}";
var baseMetaKey = $"{projectId}/{BASE_META}";
var baseMetaPath = $"{localDir}/{BASE_META}";
var deltaKey = $"{projectId}/{fileName}{DELTA_SUFFIX}";
var deltaPath = $"{filePath}{DELTA_SUFFIX}";
var baseSignature = $"{fileName}{SIG_SUFFIX}";
var baseSignaturePath = $"{localDir}/{baseSignature}";
string hashPattern = @"(?<=" + projectId + @"/)(.*)(?=\.zip$)";
string projectHash = new Regex(hashPattern).Match(fileKey).Value;
clearOldFiles(baseMetaPath, baseSignaturePath, deltaPath);
messageCb(COS_MSG.TITLE_DOWNLOADING_META_FILE,
string.Format(COS_MSG.INFO_DOWNLOADING_META_FILE, baseMetaKey, $"{localDir}/{BASE_META}"));
syncDownloadFile(deltaBucket, baseMetaKey, localDir, BASE_META,
progressCb, DoNothing, failedCb);
var metaInfo = JsonConvert.DeserializeObject <MetaInfo>(File.ReadAllText(baseMetaPath));
if ((float)new FileInfo(filePath).Length / metaInfo.baseFileSize > 1 + DELTA_THRESHOLD)
{
clearOldFiles(baseMetaPath);
_InitProject(filePath, projectId, progressCb, messageCb, successCb, failedCb);
return;
}
ucbFacade.InitDeltaUpload(new DeltaInfo
{
baseFileKey = metaInfo.baseFileName,
deltaFileKey = $"{fileKey}{DELTA_SUFFIX}",
newFileKey = fileKey,
projectId = projectId,
fileHash = projectHash
});
messageCb(COS_MSG.TITLE_DOWNLOADING_SIG_FILE,
string.Format(COS_MSG.INFO_DOWNLOADING_SIG_FILE, metaInfo.signatureKey, $"{localDir}/{baseSignature}"));
syncDownloadFile(deltaBucket, metaInfo.signatureKey, localDir, baseSignature,
progressCb, DoNothing, failedCb);
messageCb(COS_MSG.TITLE_CREATING_DELTA_FILE,
string.Format(COS_MSG.INFO_CREATING_DELTA_FILE, deltaPath, filePath, baseSignaturePath));
CreateDelta(filePath, baseSignaturePath, deltaPath);
if ((float)new FileInfo(deltaPath).Length / metaInfo.baseFileSize > DELTA_THRESHOLD)
{
clearOldFiles(baseMetaPath, baseSignaturePath, deltaPath);
_InitProject(filePath, projectId, progressCb, messageCb, successCb, failedCb);
return;
}
messageCb(COS_MSG.TITLE_UPLOADING_DELTA_FILE,
string.Format(COS_MSG.INFO_UPLOADING_DELTA_FILE, deltaKey));
UploadFile(deltaBucket, deltaKey, deltaPath, progressCb,
delegate(CosResult uploadResult)
{
deltaPatch(metaInfo.baseFileName, fileKey, projectId, projectHash);
clearOldFiles(baseMetaPath, baseSignaturePath, deltaPath);
messageCb(COS_MSG.TITLE_PATCHING_DELTA_FILE, COS_MSG.INFO_PATCHING_DELTA_FILE);
}, failedCb);
}
