public static void EnsureLoaded(this sw.FrameworkElement control) { ApplicationHandler.InvokeIfNecessary(() => { if (!control.IsLoaded) { control.Dispatcher.Invoke(new Action(() => { }), sw.Threading.DispatcherPriority.ApplicationIdle, null); } }); }
/// <summary> /// Construct a new LUIS subscription manager based on a Subscription Key. /// </summary> /// <param name="subscriptionKey">The subscription key of the LUIS account.</param> /// <param name="domain">String to represent the domain of the endpoint.</param> /// <param name="baseUri">Root URI for the service endpoint.</param> public LuisManager(string subscriptionKey, string domain = DEFAULT_DOMAIN, string baseUri = DEFAULT_BASE_URI) { if (string.IsNullOrEmpty(subscriptionKey)) { throw new ArgumentNullException(nameof(subscriptionKey)); } BASE_API_URL = string.Format(baseUri, domain); Apps = new ApplicationHandler(subscriptionKey, BASE_API_URL); }
public MyAppNode(NodeInfo identity, MyAppNodeConfiguration config) : base(identity, config) { var factory = new MyAppDataFactory(config.LoggerDelegate); _appRepo = new MyAppDataRepo(factory.CreateMyAppData); _appHandler = new ApplicationHandler(this); MessageBus.Subscribe(_appHandler); MessageBus.Subscribe(_appRepo); }
public ActionResult applicationInfo(ApplicationManager app) { if (ModelState.IsValid) { ApplicationHandler application = new ApplicationHandler(); application.AddApp(app); return(RedirectToAction("successPage")); } return(View(app)); }
public void Unlock(BitmapData bitmapData) { ApplicationHandler.InvokeIfNecessary(() => { var wb = Control as swm.Imaging.WriteableBitmap; if (wb != null) { wb.AddDirtyRect(new sw.Int32Rect(0, 0, Size.Width, Size.Height)); wb.Unlock(); } }); }
public void TaskFinished(SnTaskResult taskResult) { SnTrace.TaskManagement.Write("AgentHub TaskFinished called. Agent: {0} / {1}, taskId: {2}, code: {3}, error: {4}", taskResult.MachineName, taskResult.AgentName, taskResult.Task.Id, taskResult.ResultCode, taskResult.Error == null ? "" : taskResult.Error.Message); try { if (string.IsNullOrEmpty(taskResult.Task.AppId)) { SnLog.WriteWarning($"AppId is empty for task #{taskResult.Task.Id}.", EventId.TaskManagement.Lifecycle); return; } var doesApplicationNeedNotification = !string.IsNullOrWhiteSpace(taskResult.Task.GetFinalizeUrl()); // first we make sure that the app is accessible by sending a ping request if (doesApplicationNeedNotification && !ApplicationHandler.SendPingRequest(taskResult.Task.AppId)) { var app = ApplicationHandler.GetApplication(taskResult.Task.AppId); SnLog.WriteError(string.Format("Ping request to application {0} ({1}) failed when finalizing task #{2}. Task success: {3}, error: {4}", taskResult.Task.AppId, app == null ? "unknown app" : app.ApplicationUrl, taskResult.Task.Id, taskResult.Successful, taskResult.Error == null ? "-" : taskResult.Error.ToString()), EventId.TaskManagement.Communication); doesApplicationNeedNotification = false; } // remove the task from the database first TaskDataHandler.FinalizeTask(taskResult); SnTrace.TaskManagement.Write("AgentHub TaskFinished: task {0} has been deleted.", taskResult.Task.Id); if (doesApplicationNeedNotification) { // This method does not need to be awaited, because we do not want to do anything // with the result, only notify the app that the task has been finished. ApplicationHandler.SendFinalizeNotificationAsync(taskResult); } // notify monitors TaskMonitorHub.OnTaskEvent(taskResult.Successful ? SnTaskEvent.CreateDoneEvent(taskResult.Task.Id, taskResult.Task.Title, taskResult.ResultData, taskResult.Task.AppId, taskResult.Task.Tag, taskResult.MachineName, taskResult.AgentName) : SnTaskEvent.CreateFailedEvent(taskResult.Task.Id, taskResult.Task.Title, taskResult.ResultData, taskResult.Task.AppId, taskResult.Task.Tag, taskResult.MachineName, taskResult.AgentName)); } catch (Exception ex) { SnLog.WriteException(ex, "AgentHub TaskFinished failed.", EventId.TaskManagement.General); } }
public BitmapData Lock() { return(ApplicationHandler.InvokeIfNecessary(() => { var wb = Control as swmi.WriteableBitmap; if (wb == null) { wb = new swmi.WriteableBitmap(Control); SetBitmap(wb); } wb.Lock(); return new BitmapDataHandler(Widget, wb.BackBuffer, Stride, Control.Format.BitsPerPixel, wb); })); }
public static void EnsureLoaded(this sw.FrameworkElement control) { ApplicationHandler.InvokeIfNecessary(() => { #if TODO_XAML if (!control.IsLoaded) { control.Dispatcher.Invoke(new Action(() => { }), sw.Threading.DispatcherPriority.ContextIdle, null); } #else throw new NotImplementedException(); #endif }); }
public BitmapData Lock() { if (isLocked) { throw new InvalidOperationException(); } BitmapDataHandler bd = null; ApplicationHandler.InvokeIfNecessary(() => { Control.Lock(); bd = new BitmapDataHandler(Widget, Control.BackBuffer, Size.Width, Control.Format.BitsPerPixel, Control); }); isLocked = true; return(bd); }
public void RegisterApplication(RegisterApplicationRequest appRequest) { try { var app = TaskDataHandler.RegisterApplication(appRequest); } catch (Exception ex) { // the client app needs to be notified throw new HttpResponseException(Request.CreateErrorResponse(HttpStatusCode.NotFound, ex)); } // invalidate app cache ApplicationHandler.Reset(); }
public ActionResult DeleteApp(FormCollection form) { int num = Convert.ToInt32(form["applicationId"].ToString()); if (ModelState.IsValid) { ApplicationHandler application = new ApplicationHandler(); ICollection <ApplicationManager> data = application.GetAllApps(); ApplicationManager appManager = new ApplicationManager(); appManager = data.Single(x => x.applicationId == num); data.Remove(appManager); return(RedirectToAction("successPage")); } return(RedirectToAction("ErrorLogin")); }
public void Create(int width, int height, int bitsPerPixel) { Size = new Size(width, height); var format = swm.PixelFormats.Indexed8; numColors = (int)Math.Pow(2, bitsPerPixel); var colors = new List <swm.Color> (numColors); while (colors.Count < numColors) { colors.Add(swm.Colors.Black); } ApplicationHandler.InvokeIfNecessary(() => { Control = new swmi.WriteableBitmap(width, height, 96, 96, format, new swmi.BitmapPalette(colors)); }); }
public void Unlock(BitmapData bitmapData) { if (!isLocked) { throw new InvalidOperationException(); } ApplicationHandler.InvokeIfNecessary(() => { Control.AddDirtyRect(new sw.Int32Rect(0, 0, Size.Width, Size.Height)); Control.Unlock(); if (paletteSetInLocked) { SetPalette(); paletteSetInLocked = false; } }); isLocked = false; }
public void Create(Image image, int width, int height, ImageInterpolation interpolation) { ApplicationHandler.InvokeIfNecessary(() => { var source = image.ToWpf(); // use drawing group to allow for better quality scaling var group = new swm.DrawingGroup(); swm.RenderOptions.SetBitmapScalingMode(group, interpolation.ToWpf()); group.Children.Add(new swm.ImageDrawing(source, new sw.Rect(0, 0, width, height))); var drawingVisual = new swm.DrawingVisual(); using (var drawingContext = drawingVisual.RenderOpen()) drawingContext.DrawDrawing(group); var resizedImage = new swm.Imaging.RenderTargetBitmap(width, height, source.DpiX, source.DpiY, swm.PixelFormats.Default); resizedImage.Render(drawingVisual); Control = resizedImage; }); }
static void Main(string[] args) { string jsonFilePath; ApplicationJson appJson = new ApplicationJson(); Console.WriteLine(); #if DEBUG jsonFilePath = "appsettings.json"; #else jsonFilePath = args[0]; #endif try { Console.WriteLine("Reading settings from appsettings.json . . ."); Console.WriteLine(jsonFilePath); appJson = JsonConvert.DeserializeObject <ApplicationJson>(File.ReadAllText(jsonFilePath)); if (appJson.Application == null || appJson.Server == null) { throw new ArgumentNullException("appsettings data is NULL"); } Console.WriteLine("Reading complete"); } catch (Exception ex) { Console.WriteLine("Reading Error:"); Console.WriteLine(ex.ToString()); Console.ReadLine(); Environment.Exit(0); } Console.WriteLine(); Console.WriteLine("Autobackup starting by " + Environment.UserName + " . . ."); Console.WriteLine(); ApplicationHandler appHandler = new ApplicationHandler(appJson.Application, appJson.Server); Console.WriteLine(); Console.WriteLine("AutoBackuping Finished"); }
public Bitmap Clone(Rectangle?rectangle = null) { var clone = ApplicationHandler.InvokeIfNecessary(() => { if (rectangle != null) { var rect = rectangle.Value; var data = new byte[Stride * Control.PixelHeight]; Control.CopyPixels(data, Stride, 0); var target = new swmi.WriteableBitmap(rect.Width, rect.Height, Control.DpiX, Control.DpiY, Control.Format, Control.Palette); target.WritePixels(rect.ToWpfInt32(), data, Stride, destinationX: 0, destinationY: 0); return(target); } else { return(Control.Clone()); } }); return(new Bitmap(new BitmapHandler(clone))); }
public BitmapData Lock() { BitmapDataHandler handler = null; ApplicationHandler.InvokeIfNecessary(() => { var wb = Control as swm.Imaging.WriteableBitmap; if (wb != null) { wb.Lock(); handler = new BitmapDataHandler(Widget, wb.BackBuffer, (int)stride, Control.Format.BitsPerPixel, Control); } else { wb = new swm.Imaging.WriteableBitmap(Control); wb.Lock(); Control = wb; handler = new BitmapDataHandler(Widget, wb.BackBuffer, (int)stride, Control.Format.BitsPerPixel, wb); } }); return(handler); }
public Bitmap Clone(Rectangle?rectangle = null) { swmi.BitmapSource clone = null; ApplicationHandler.InvokeIfNecessary(() => { if (rectangle != null) { var rect = rectangle.Value; int stride = Control.PixelWidth * (Control.Format.BitsPerPixel / 8); byte[] data = new byte[stride * Control.PixelHeight]; Control.CopyPixels(data, stride, 0); var target = new swmi.WriteableBitmap(rect.Width, rect.Height, Control.DpiX, Control.DpiY, Control.Format, null); target.WritePixels(rect.ToWpfInt32(), data, stride, destinationX: 0, destinationY: 0); clone = target; } else { clone = Control.Clone(); } }); return(new Bitmap(Generator, new BitmapHandler(clone))); }
public static void DisconnectAll() { List <Socket> list = new List <Socket>(); lock (ConnectionManager.thisManagerLock) { if (ConnectionManager.allConnections.Count > 0) { foreach (KeyValuePair <Socket, ConnectionContext> current in ConnectionManager.allConnections) { Socket key = current.Key; list.Add(key); key.Close(); } } ConnectionManager.allConnections.Clear(); } foreach (Socket current2 in list) { ApplicationHandler.DelegateOnLinkDown(current2, ""); } }
public List <SocketAsyncEventArgs> IncommingHandler(SocketAsyncEventArgs receiveEventArg) { int i = 0; List <SocketAsyncEventArgs> list = new List <SocketAsyncEventArgs>(); while (i < receiveEventArg.BytesTransferred) { int num = 1600 - this.nRemainingBytes; if (num == 0) { return(null); } if (receiveEventArg.BytesTransferred - i < num) { num = receiveEventArg.BytesTransferred - i; } Buffer.BlockCopy(receiveEventArg.Buffer, receiveEventArg.Offset + i, this.receiveBuffer, this.nRemainingBytes, num); this.nRemainingBytes += num; i += num; while (this.nRemainingBytes > 0) { bool flag = false; int j; for (j = 0; j < this.nRemainingBytes; j++) { if (this.receiveBuffer[j] == 13 || this.receiveBuffer[j] == 10) { flag = true; break; } } if (!flag) { break; } int num2 = j; while (num2 < this.nRemainingBytes && (this.receiveBuffer[num2] == 13 || this.receiveBuffer[num2] == 10)) { num2++; } if (j > 0) { byte[] array = ApplicationHandler.ProtocolParser(receiveEventArg.AcceptSocket, this.status.nAuthorized, this.receiveBuffer, 0, j); if (array != null) { SocketAsyncEventArgs socketAsyncEventArgs = new SocketAsyncEventArgs(); if (socketAsyncEventArgs != null) { socketAsyncEventArgs.AcceptSocket = receiveEventArg.AcceptSocket; socketAsyncEventArgs.SetBuffer(array, 0, array.Length); socketAsyncEventArgs.UserToken = null; list.Add(socketAsyncEventArgs); } } } this.nRemainingBytes -= num2; if (this.nRemainingBytes > 0) { Buffer.BlockCopy(this.receiveBuffer, num2, this.receiveBuffer, 0, this.nRemainingBytes); } } } return(list); }
public DNP3Handler() { DNP3ApplicationHandler = new ApplicationHandler(); DNP3DataLinkHandler = new DataLinkHandler(); }
public void Create(System.IO.Stream stream) { ApplicationHandler.InvokeIfNecessary(() => { Control = swmi.BitmapFrame.Create(stream, swmi.BitmapCreateOptions.None, swmi.BitmapCacheOption.OnLoad); }); }
public void Create(string fileName) { ApplicationHandler.InvokeIfNecessary(() => { Control = swmi.BitmapFrame.Create(new Uri(fileName), swmi.BitmapCreateOptions.None, swmi.BitmapCacheOption.OnLoad); }); }
public static void LocalToShareEx(Dictionary <string, Gateway> gts, bool bRemoveOffline) { if (!SharedData.IsProducer()) { return; } if (SharedData.semaphoreInSnergy == null) { return; } if (gts.Count <= 0) { lock (SharedData.thisSharedLock) { if (SharedData.semaphoreInSnergy != null) { SharedData.semaphoreInSnergy.WaitOne(); SharedData.WriteShareLong(32L, 0L); SharedData.WriteShareLong(48L, 0L); SharedData.semaphoreInSnergy.Release(); } } return; } byte[] array = new byte[SharedData.MAX_SHARE_DATA_SIZE + 1024L]; Array.Clear(array, 0, array.Length); long num = 0L; long num2 = 0L; long num3 = 0L; long num4 = 0L; long num5 = 0L; foreach (KeyValuePair <string, Gateway> current in gts) { byte[] bytes = Encoding.ASCII.GetBytes(current.Key); string[] array2 = current.Value.status.gatewayIP.Split(new char[] { ':' }); DateTime tUptime = current.Value.status.tUptime; if (ApplicationHandler.IsTopologyNotEmpty(current.Key) && (!bRemoveOffline || current.Value.status.gatewayIP.IndexOf(":0") < 0)) { num5 += 1L; if (num2 >= SharedData.MAX_SHARE_DATA_SIZE || num3 > 0L) { num3 = 1L; } else { Buffer.BlockCopy(bytes, 0, array, (int)num2, 20); num2 += 20L; byte[] array3 = new byte[6]; Array.Clear(array3, 0, array3.Length); if (array2.Length == 2) { string[] array4 = array2[0].Split(new char[] { '.' }); if (array4.Length == 4) { array3[0] = Convert.ToByte(array4[0]); array3[1] = Convert.ToByte(array4[1]); array3[2] = Convert.ToByte(array4[2]); array3[3] = Convert.ToByte(array4[3]); array3[4] = (byte)(Convert.ToInt32(array2[1]) & 255); array3[5] = (byte)(Convert.ToInt32(array2[1]) >> 8); } } Buffer.BlockCopy(array3, 0, array, (int)num2, 6); num2 += 6L; long value = ((long)tUptime.Year << 40) + ((long)tUptime.Month << 32) + ((long)tUptime.Day << 24) + (long)((long)tUptime.Hour << 16) + (long)((long)tUptime.Minute << 8) + (long)tUptime.Second; byte[] bytes2 = BitConverter.GetBytes(value); Buffer.BlockCopy(bytes2, 0, array, (int)num2, 8); num2 += 8L; Array.Clear(array3, 0, array3.Length); array3[0] = Convert.ToByte(current.Value.listDevice.Count); Buffer.BlockCopy(array3, 0, array, (int)num2, 1); num2 += 1L; foreach (KeyValuePair <string, Device> current2 in current.Value.listDevice) { if (num2 >= SharedData.MAX_SHARE_DATA_SIZE) { num3 = 1L; InSnergyService.PostLog("OutOfMem #2"); break; } byte[] bytes3 = Encoding.ASCII.GetBytes(current2.Value.sDID); Buffer.BlockCopy(bytes3, 0, array, (int)num2, 20); num2 += 20L; long num6 = num2; Array.Clear(array3, 0, array3.Length); array3[0] = Convert.ToByte(current2.Value.listChannel.Count); Buffer.BlockCopy(array3, 0, array, (int)num2, 1); num2 += 1L; long num7 = 0L; foreach (KeyValuePair <string, Channel> current3 in current2.Value.listChannel) { if (num2 >= SharedData.MAX_SHARE_DATA_SIZE) { num3 = 1L; InSnergyService.PostLog("OutOfMem #3"); break; } int num8 = Convert.ToInt32(current3.Value.sCID); if (num8 >= 1 && num8 <= 12) { int num9 = current2.Value.mapChannel[num8 - 1]; if (num9 != 0) { string text = num8.ToString(); while (text.Length < 2) { text = "0" + text; } for (int i = 0; i < 3; i++) { string str = "0" + (i + 1).ToString(); string text2 = (num9 >> 8 * (2 - i) & 255).ToString(); while (text2.Length < 2) { text2 = "0" + text2; } if (!(text2 == "00")) { byte[] bytes4 = Encoding.ASCII.GetBytes(text + str + text2); Buffer.BlockCopy(bytes4, 0, array, (int)num2, 6); num2 += 6L; long num10 = num2; Array.Clear(array3, 0, array3.Length); array3[0] = Convert.ToByte(current3.Value.measurePair.Count); Buffer.BlockCopy(array3, 0, array, (int)num2, 1); num2 += 1L; long num11 = 0L; foreach (KeyValuePair <string, Param> current4 in current3.Value.measurePair) { int num12 = Convert.ToInt32(current4.Value.aID); if ((SharedData.listParamEnabled == null || SharedData.listParamEnabled.Contains(num12)) && num12 > 1000 && num12 / 1000 == i + 1) { if (num2 >= SharedData.MAX_SHARE_DATA_SIZE) { num3 = 1L; InSnergyService.PostLog("OutOfMem #4"); break; } byte[] bytes5 = BitConverter.GetBytes(num12); Buffer.BlockCopy(bytes5, 0, array, (int)num2, 4); num2 += 4L; byte[] bytes6 = BitConverter.GetBytes(current4.Value.dvalue); Buffer.BlockCopy(bytes6, 0, array, (int)num2, 8); num2 += 8L; value = ((long)current4.Value.time.Year << 40) + ((long)current4.Value.time.Month << 32) + ((long)current4.Value.time.Day << 24) + (long)((long)current4.Value.time.Hour << 16) + (long)((long)current4.Value.time.Minute << 8) + (long)current4.Value.time.Second; bytes2 = BitConverter.GetBytes(value); Buffer.BlockCopy(bytes2, 0, array, (int)num2, 8); num2 += 8L; num11 += 1L; } } if (num3 > 0L) { break; } Array.Clear(array3, 0, array3.Length); array3[0] = Convert.ToByte(num11); Buffer.BlockCopy(array3, 0, array, (int)num10, 1); num7 += 1L; } } } } } if (num3 > 0L) { break; } Array.Clear(array3, 0, array3.Length); array3[0] = Convert.ToByte(num7); Buffer.BlockCopy(array3, 0, array, (int)num6, 1); } if (num3 <= 0L) { num += 1L; num4 = num2; } } } } Array.Resize <byte>(ref array, (int)num4); lock (SharedData.thisSharedLock) { if (SharedData.semaphoreInSnergy != null) { num += num5 << 32; SharedData.semaphoreInSnergy.WaitOne(); SharedData.WriteShareLong(32L, num); SharedData.WriteShareLong(48L, num4); SharedData.WriteShareArray(8280L, array); long num13 = SharedData.ReadShareLong(56L); num13 |= 8L; SharedData.WriteShareLong(56L, num13); SharedData.semaphoreInSnergy.Release(); } } if (num3 > 0L) { if (num3 != SharedData.nLastShareMemoryErrorCode) { InSnergyService.PostLog("Out of share-memory, data truncated"); } SharedData.WriteStatus(2L, true); } else { SharedData.WriteStatus(2L, false); } SharedData.nLastShareMemoryErrorCode = num3; }
public List <UserLevelObject> PackUp(byte[] data) { BitArray header = new BitArray(new byte[] { data[0] }); BitArray tempHeader = new BitArray(header); tempHeader[7] = false; tempHeader[6] = false; byte[] tempSeq = new byte[1]; tempHeader.CopyTo(tempSeq, 0); byte newSeq = tempSeq[0]; if (header[6] == true) { Fir = true; sequence = newSeq; appSegments.Clear(); } else if (!Fir) { return(null); } else if (newSeq != sequence + 1) { return(null); } sequence++; Fin = header[7]; int length = data.Count() - 1; byte[] appData = new byte[length]; for (int i = 0; i < length; i++) { appData[i] = data[i + 1]; } appSegments.Add(appData); if (Fin) { Fir = false; Fin = false; int totalLength = 0; foreach (byte[] segment in appSegments) { totalLength += segment.Count(); } byte[] finalAppData = new byte[totalLength]; int index = 0; foreach (byte[] segment in appSegments) { segment.CopyTo(finalAppData, index); index += segment.Count(); } appSegments.Clear(); DNP3ApplicationHandler = new ApplicationHandler(); return(DNP3ApplicationHandler.PackUp(finalAppData)); } else { return(null); } }
public AgentHub(IHubContext <TaskMonitorHub> monitorHub, ApplicationHandler appHandler, TaskDataHandler dataHandler) { _monitorHub = monitorHub; _applicationHandler = appHandler; _dataHandler = dataHandler; }
public static void MapWindowSoftInputModeAdjust(ApplicationHandler handler, Application application) { Platform.ApplicationExtensions.UpdateWindowSoftInputModeAdjust(handler.PlatformView, application); }
public RegisterTaskResult RegisterTask(RegisterTaskRequest taskRequest) { Application app = null; try { // load the corresponding application to make sure the appid is valid app = ApplicationHandler.GetApplication(taskRequest.AppId); } catch (Exception ex) { SnLog.WriteException(ex, "Error loading app for id " + taskRequest.AppId, EventId.TaskManagement.General); } // If we do not know the appid, we must not register the task. Client applications // must observe this response and try to re-register the application, before // trying to register the task again (this can happen if the TaskManagement Web // was unreachable when the client application tried to register the appid before). if (app == null) { throw new HttpResponseException(Request.CreateErrorResponse(HttpStatusCode.NotFound, RegisterTaskRequest.ERROR_UNKNOWN_APPID)); } RegisterTaskResult result = null; try { // calculate hash with the default algrithm if not given var hash = taskRequest.Hash == 0 ? ComputeTaskHash(taskRequest.Type + taskRequest.AppId + taskRequest.Tag + taskRequest.TaskData) : taskRequest.Hash; result = TaskDataHandler.RegisterTask( taskRequest.Type, taskRequest.Title, taskRequest.Priority, taskRequest.AppId, taskRequest.Tag, taskRequest.FinalizeUrl, hash, taskRequest.TaskData, taskRequest.MachineName); } catch (Exception ex) { // the client app needs to be notified throw new HttpResponseException(Request.CreateErrorResponse(HttpStatusCode.NotFound, ex)); } try { // notify agents AgentHub.BroadcastMessage(result.Task); // notify monitor clients TaskMonitorHub.OnTaskEvent(SnTaskEvent.CreateRegisteredEvent( result.Task.Id, result.Task.Title, string.Empty, result.Task.AppId, result.Task.Tag, null, result.Task.Type, result.Task.Order, result.Task.Hash, result.Task.TaskData)); } catch (Exception ex) { // The task has been created successfully, this error is only about // notification, so client applications should not be notified. SnLog.WriteException(ex, "Error during agent or monitor notification after a task was registered.", EventId.TaskManagement.Communication); } return(result); }
public static void LinkDownNotify(Socket sock) { ApplicationHandler.DelegateOnLinkDown(sock, "link down"); }