public void Register <TIn, TOut>(string path, DataDelegate <TIn, TOut> callback) where TIn : new()
{
_dataCallbacks[path] = async(devId, strm) =>
{
TIn data;
try
{
data = PayloadHelper.ReadData <TIn>(strm);
}
catch (Exception e)
{
_logger.Warn(e, $"Error to deserialize input data '{path}'. Payload type {typeof(TIn).Name}");
await SendError(devId, path, ErrorType.ArgsError, e.Message, CancellationToken.None);
return;
}
try
{
var result = await callback(devId, data);
await SendResult(devId, path, result, CancellationToken.None);
}
catch (Exception e)
{
Status.Error($"Execute {path}:{e.Message}");
_logger.Warn(e, $"Error to execute '{path}':{e.Message}");
await SendError(devId, path, ErrorType.InternalError, e.Message, CancellationToken.None);
}
};
}
public void DoGetMessage <T>(string queryURL, DataDelegate <T> callback)
{
#if SILVERLIGHT
Uri uri = new Uri(queryURL, UriKind.Absolute);
var request = (HttpWebRequest)WebRequest.Create(uri);
request.Method = "GET";
request.Accept = "text/json";
request.BeginGetResponse((result) =>
{
var response = request.EndGetResponse(result);
var stream = response.GetResponseStream();
if (stream != null)
{
DataContractJsonSerializer serializer = new DataContractJsonSerializer(typeof(T));
T data = (T)serializer.ReadObject(stream);
System.Windows.Deployment.Current.Dispatcher.BeginInvoke(() =>
{
callback(data);
});
}
else
{
System.Windows.Deployment.Current.Dispatcher.BeginInvoke(() =>
{
callback(default(T));
});
}
}, null);
#endif
}
protected void Register <TIn, TOut>(string path, DataDelegate <TIn, TOut> callback) where TIn : new()
{
if (!path.StartsWith(_name, StringComparison.InvariantCultureIgnoreCase))
{
var absolutePath = PayloadHelper.PathJoin(_name, path);
_server.Register(absolutePath, callback);
}
}
public DataImportWizardP2(string file)
{
_excelFile = file;
_dbManager = DBAccessManager.GetInstance();
InitializeComponent();
_dlgLbl = new DataDelegate(Update);
_dlgPrg = new ProgressDelegate(UpdateProgress);
new Thread(() => LoadData()).Start();
}
private static void OnIncomingDataEvent(string[] data)
{
DataDelegate handler = IncomingDataEvent;
if (handler != null)
{
handler(data);
}
}
/// <summary>
/// Sets the function at index to use dd. Note that this uses +=, so multicasting is possible.
/// </summary>
/// <param name="index">index of the function</param>
/// <param name="dd">DataDelegate of the form "double dd (object)"</param>
public static void SetFunction(int index, DataDelegate dd)
{
if (index >= NumberOfFunctions || index < 0)
{
throw new IndexOutOfRangeException();
}
else
{
functions[index] += dd;
}
}
protected void SendData()
{
if (this.label1.InvokeRequired)
{
DataDelegate dd = new DataDelegate(SendData);
this.Invoke(dd);
}
else
{
this.label1.Text = this.A.ToString();
this.Redraw();
}
}
private static void reinforceConstantRelations()
{
_notFlagStart = 0;
_functionStart = _notFlagStart + _notFlagLength;
NumberOfFunctions = OptoGlobals.NumberOfFeatures;
_functionLength = (int)Math.Ceiling(Math.Log(NumberOfFunctions, 2)); //So our cells will have enough bits to carry the necessary number of functions
_lLimitStart = _functionStart + _functionLength;
_uLimitStart = _lLimitStart + limitLength;
_joinBitStart = _uLimitStart + limitLength;
CellLength = _joinBitStart + _notFlagLength;
functions = new DataDelegate[NumberOfFunctions];
initDelegatesAndNames();
}
/// <summary>
/// Sets the function at index to use dd. Note that this uses -=.
/// </summary>
/// <param name="index">index of the function</param>
/// <param name="dd">DataDelegate of the form "double dd (object)"</param>
public static void RemoveFunction(int index, DataDelegate dd)
{
if (index >= NumberOfFunctions || index < 0)
{
throw new IndexOutOfRangeException();
}
else
{
if (functions[index] != null && dd != null)
{
functions[index] -= dd;
}
}
}
public MessageHandler(
ClientCollection clients,
DataDelegate dataHandler,
ConnectionDelegate connectionHandler,
TerminalDelegate terminalHandler,
SecurityDelegate securityHandler
)
{
this.clients = clients;
this.DataHandler = dataHandler;
this.ConnectionHandler = connectionHandler;
this.TerminalHandler = terminalHandler;
this.SecurityHandler = securityHandler;
}
public override void ViewDidLoad()
{
base.ViewDidLoad();
RequestToServer req = new RequestToServer(this);
BBCNews data = new BBCNews();
_data = new BBCNewsList(data);
_btnSearch.TouchUpInside += Search_Clicked;
_searchTextField.Text = "";
_myCollectionView.RegisterNibForCell(MyCollectionViewCell.Nib, MyCollectionViewCell.Key);
_dataDelegate = new DataDelegate();
_myCollectionView.Delegate = _dataDelegate;
_myCollectionView.DataSource = new DataSourceNews(this, _data, NavigationController);
}
/// <summary>
/// Sets up a message for streaming consumption.
/// </summary>
/// <param name="onData">Called whenever new data is available</param>
/// <param name="onEnd">Called at the end of the message</param>
public void Consume(DataDelegate onData, EndDelegate onEnd)
{
if (Consumed)
{
throw new InvalidOperationException("consumption already started");
}
if (onData == null)
{
throw new ArgumentNullException("onData");
}
if (onEnd == null)
{
throw new ArgumentNullException("onEnd");
}
this.onData = onData;
this.onEnd = onEnd;
}
public void setCallBackDelegate(DataDelegate _delegate)
{
dataDelegate = _delegate;
}
public NormalDownloader(IStorageWrapper storageWrapper, IPiecePicker piecePicker, int backLog, double maxRatePeriod,
int piecesNumber, Measure downloadMeasure, double snubTime, DataDelegate measureFunction)
{
this.storageWrapper = storageWrapper;
this.piecePicker = piecePicker;
this.backLog = backLog;
this.maxRatePeriod = maxRatePeriod;
this.downloadMeasure = downloadMeasure;
this.piecesNumber = piecesNumber;
this.snubTime = snubTime;
this.measureFunction = measureFunction;
this.downloads = new List <SingleDownload>();
}
/// <summary>
/// Processes a websocket frame and triggers consumer events
/// </summary>
/// <param name="psocketState">We need to modify the websocket state here depending on the frame</param>
private void ProcessFrame(WebSocketState psocketState)
{
if (psocketState.Header.IsMasked)
{
byte[] unmask = psocketState.ReceivedBytes.ToArray();
WebSocketReader.Mask(psocketState.Header.Mask, unmask);
psocketState.ReceivedBytes = new List <byte>(unmask);
}
switch (psocketState.Header.Opcode)
{
case WebSocketReader.OpCode.Ping:
PingDelegate pingD = OnPing;
if (pingD != null)
{
pingD(this, new PingEventArgs());
}
WebSocketFrame pongFrame = new WebSocketFrame()
{
Header = WebsocketFrameHeader.HeaderDefault(), WebSocketPayload = new byte[0]
};
pongFrame.Header.Opcode = WebSocketReader.OpCode.Pong;
pongFrame.Header.IsEnd = true;
SendSocket(pongFrame.ToBytes());
break;
case WebSocketReader.OpCode.Pong:
PongDelegate pongD = OnPong;
if (pongD != null)
{
pongD(this, new PongEventArgs()
{
PingResponseMS = Util.EnvironmentTickCountSubtract(Util.EnvironmentTickCount(), _pingtime)
});
}
break;
case WebSocketReader.OpCode.Binary:
if (!psocketState.Header.IsEnd) // Not done, so we need to store this and wait for the end frame.
{
psocketState.ContinuationFrame = new WebSocketFrame
{
Header = psocketState.Header,
WebSocketPayload =
psocketState.ReceivedBytes.ToArray()
};
}
else
{
// Send Done Event!
DataDelegate dataD = OnData;
if (dataD != null)
{
dataD(this, new WebsocketDataEventArgs()
{
Data = psocketState.ReceivedBytes.ToArray()
});
}
}
break;
case WebSocketReader.OpCode.Text:
if (!psocketState.Header.IsEnd) // Not done, so we need to store this and wait for the end frame.
{
psocketState.ContinuationFrame = new WebSocketFrame
{
Header = psocketState.Header,
WebSocketPayload =
psocketState.ReceivedBytes.ToArray()
};
}
else
{
TextDelegate textD = OnText;
if (textD != null)
{
textD(this, new WebsocketTextEventArgs()
{
Data = Encoding.UTF8.GetString(psocketState.ReceivedBytes.ToArray())
});
}
// Send Done Event!
}
break;
case WebSocketReader.OpCode.Continue: // Continuation. Multiple frames worth of data for one message. Only valid when not using Control Opcodes
//Console.WriteLine("currhead " + psocketState.Header.IsEnd);
//Console.WriteLine("Continuation! " + psocketState.ContinuationFrame.Header.IsEnd);
byte[] combineddata = new byte[psocketState.ReceivedBytes.Count + psocketState.ContinuationFrame.WebSocketPayload.Length];
byte[] newdata = psocketState.ReceivedBytes.ToArray();
Buffer.BlockCopy(psocketState.ContinuationFrame.WebSocketPayload, 0, combineddata, 0, psocketState.ContinuationFrame.WebSocketPayload.Length);
Buffer.BlockCopy(newdata, 0, combineddata,
psocketState.ContinuationFrame.WebSocketPayload.Length, newdata.Length);
psocketState.ContinuationFrame.WebSocketPayload = combineddata;
psocketState.Header.PayloadLen = (ulong)combineddata.Length;
if (psocketState.Header.IsEnd)
{
if (psocketState.ContinuationFrame.Header.Opcode == WebSocketReader.OpCode.Text)
{
// Send Done event
TextDelegate textD = OnText;
if (textD != null)
{
textD(this, new WebsocketTextEventArgs()
{
Data = Encoding.UTF8.GetString(combineddata)
});
}
}
else if (psocketState.ContinuationFrame.Header.Opcode == WebSocketReader.OpCode.Binary)
{
// Send Done event
DataDelegate dataD = OnData;
if (dataD != null)
{
dataD(this, new WebsocketDataEventArgs()
{
Data = combineddata
});
}
}
else
{
// protocol violation
}
psocketState.ContinuationFrame = null;
}
break;
case WebSocketReader.OpCode.Close:
Close(string.Empty);
break;
}
psocketState.Header.SetDefault();
psocketState.ReceivedBytes.Clear();
psocketState.ExpectedBytes = 0;
}
public void Init(Syscalls syscalls, Core core, Runtime runtime)
{
runtime.RegisterCleaner(delegate()
{
foreach (KeyValuePair <int, Connection> p in mConnections)
{
p.Value.close();
}
mConnections.Clear();
});
mResultHandler = delegate(int handle, int connOp, int result)
{
Memory evt = new Memory(4 * 4);
evt.WriteInt32(MoSync.Struct.MAEvent.type, MoSync.Constants.EVENT_TYPE_CONN);
evt.WriteInt32(MoSync.Struct.MAEvent.conn.handle, handle);
evt.WriteInt32(MoSync.Struct.MAEvent.conn.opType, connOp);
evt.WriteInt32(MoSync.Struct.MAEvent.conn.result, result);
runtime.PostEvent(new Event(evt));
};
syscalls.maConnect = delegate(int _url)
{
String url = core.GetDataMemory().ReadStringAtAddress(_url);
//Util.Log("maConnect(" + url + ")\n");
if (url.StartsWith("btspp"))
{
return(MoSync.Constants.CONNERR_UNAVAILABLE);
}
Uri uri = new Uri(url);
Connection c;
if (uri.Scheme.Equals("socket"))
{
c = new SocketConnection(uri, mNextConnHandle);
}
else if (uri.Scheme.Equals("http") || uri.Scheme.Equals("https"))
{
c = new WebRequestConnection(uri, mNextConnHandle, MoSync.Constants.HTTP_GET);
}
else
{
return(MoSync.Constants.CONNERR_GENERIC);
}
c.connect(mResultHandler);
mConnections.Add(mNextConnHandle, c);
return(mNextConnHandle++);
};
syscalls.maConnClose = delegate(int _conn)
{
Connection c = mConnections[_conn];
c.close();
mConnections.Remove(_conn);
};
syscalls.maConnGetAddr = delegate(int _conn, int _addr)
{
if (_conn == MoSync.Constants.HANDLE_LOCAL) // unavailable
{
return(-1);
}
Connection c = mConnections[_conn];
return(c.getAddr(core.GetDataMemory(), _addr));
};
syscalls.maConnRead = delegate(int _conn, int _dst, int _size)
{
Connection c = mConnections[_conn];
c.recv(core.GetDataMemory().GetData(), _dst, _size, mResultHandler);
};
DataDelegate dataDelegate = delegate(int _conn, int _data,
CommDelegate cd)
{
Connection c = mConnections[_conn];
Resource res = runtime.GetResource(MoSync.Constants.RT_BINARY, _data);
Stream s = (Stream)res.GetInternalObject();
runtime.SetResourceRaw(_data, Resource.Flux);
MemoryStream mem = null;
if (s.GetType() == typeof(MemoryStream))
{
mem = (MemoryStream)s;
}
else
{
MoSync.Util.CriticalError("Only binaries (non-ubins) are allowed for maConn(Read/Write)(To/From)Data");
}
cd(c, mem.GetBuffer(),
delegate(int handle, int connOp, int result)
{
runtime.SetResourceRaw(_data, res);
mResultHandler(handle, connOp, result);
});
};
syscalls.maConnReadToData = delegate(int _conn, int _data, int _offset, int _size)
{
dataDelegate(_conn, _data,
delegate(Connection c, byte[] buf, ResultHandler rh)
{
c.recv(buf, _offset, _size, rh);
});
};
syscalls.maConnWrite = delegate(int _conn, int _src, int _size)
{
Connection c = mConnections[_conn];
c.write(core.GetDataMemory().GetData(), _src, _size, mResultHandler);
};
syscalls.maConnWriteFromData = delegate(int _conn, int _data, int _offset, int _size)
{
dataDelegate(_conn, _data,
delegate(Connection c, byte[] buf, ResultHandler rh)
{
c.write(buf, _offset, _size, rh);
});
};
syscalls.maHttpCreate = delegate(int _url, int _method)
{
String url = core.GetDataMemory().ReadStringAtAddress(_url);
//Util.Log("maHttpCreate(" + url + ")\n");
Uri uri = new Uri(url);
WebRequestConnection c = new WebRequestConnection(uri, mNextConnHandle, _method);
mConnections.Add(mNextConnHandle, c);
return(mNextConnHandle++);
};
syscalls.maHttpFinish = delegate(int _conn)
{
WebRequestConnection c = (WebRequestConnection)mConnections[_conn];
c.connect(delegate(int handle, int connOp, int result)
{
mResultHandler(handle, MoSync.Constants.CONNOP_FINISH, result);
});
};
syscalls.maHttpSetRequestHeader = delegate(int _conn, int _key, int _value)
{
WebRequestConnection c = (WebRequestConnection)mConnections[_conn];
String key = core.GetDataMemory().ReadStringAtAddress(_key);
String value = core.GetDataMemory().ReadStringAtAddress(_value);
if (value.Length > 0)
{
c.setRequestHeader(key, value);
}
};
syscalls.maHttpGetResponseHeader = delegate(int _conn, int _key, int _buffer, int _bufSize)
{
WebRequestConnection c = (WebRequestConnection)mConnections[_conn];
String key = core.GetDataMemory().ReadStringAtAddress(_key);
String value = c.getResponseHeader(key);
if (value == null)
{
return(MoSync.Constants.CONNERR_NOHEADER);
}
if (value.Length + 1 <= _bufSize)
{
core.GetDataMemory().WriteStringAtAddress(_buffer, value, _bufSize);
}
return(value.Length);
};
}
/// <summary>
/// Constructor
/// </summary>
public AutoPumpQueue(DataDelegate dataDelegate)
{
m_Queue = new Queue <T>();
m_DataDelegate = dataDelegate;
}
public void setDeleteDelegate(DataDelegate command)
{
_deleteDelegate = command;
}
public void setUpdateDelegate(DataDelegate command)
{
_updateDelegate = command;
}
public static void addDelegate(DataDelegate myDelegate)
{
DataCallback += myDelegate.onDataReceived;
TurnCallback += myDelegate.onTurnReceived;
TurnCheckCallback += myDelegate.onTurnCheckReceived;
}
public void Process()
{
try
{
while (true)
{
try
{
byte[] Data = GetRequest();
MResponse ClientResponse = Package.Unpacking <MResponse>(Data);
//bool isBreak = false;
bool IsCorrectKey = false;
Debug.Log($"Новый запрос от клиента [{NetworkClient.Id} - {NetworkClient.NetPoint}]: " +
$"WindowUid - {ClientResponse.WindowUid}, KeyNetwork - {ClientResponse.KeyNetwork}");
foreach (var DataDelegate in NetworkDelegates.NetworkActions)
{
if (DataDelegate.WindowUid != -1)
{
if (DataDelegate.WindowUid == ClientResponse.WindowUid)
{
if (CheckKeyNetwork(DataDelegate, ClientResponse))
{
DataDelegate.DataDelegate(ClientResponse, NetworkClient);
IsCorrectKey = true;
//isBreak = true;
break;
}
}
}
else
{
if (CheckKeyNetwork(DataDelegate, ClientResponse))
{
DataDelegate.DataDelegate(ClientResponse, NetworkClient);
IsCorrectKey = true;
//isBreak = true;
break;
}
}
/*
* if (isBreak)
* break;
*/
}
if (!IsCorrectKey)
{
Debug.LogWarning("Не найдено делегатов с таким идентификатором!");
}
}
catch (Exception ex)
{
Debug.LogError($"Возникла ошибка при обработке пользовательского запроса.\n" +
$"Информация о пользователе: [{NetworkClient.Id}] {NetworkClient.Ip}:{NetworkClient.Port}\n" +
$"Код ошибки:\n" + ex);
break;
}
}
}
catch (Exception ex)
{
Debug.LogError("Возникла ошибка при обработке пользовательского процесса.\n" +
$"Информация о пользователе: [{NetworkClient.Id}] {NetworkClient.Ip}:{NetworkClient.Port}\n" +
$"Код ошибки:\n" + ex);
}
finally
{
Server.Users.Remove(NetworkClient);
_ServerBase.RemoveConnection(NetworkClient.Id);
Close();
Debug.Log($"Пользовательский процесс завершён.\n" +
$"Информация о пользователе: [{NetworkClient.Id}] {NetworkClient.Ip}:{NetworkClient.Port}\n");
}
}
