/// <summary> /// update the client infos /// </summary> /// <param name="pCco">the CCO</param> /// <param name="recievedFromClient">bool if request recieved from client or not</param> public void updateClient(ClientConfigObject pCco, bool recievedFromClient) { DataTable currentDataTable = getClientDataTable(); DataColumn[] primaryKeyArray = new DataColumn[1]; primaryKeyArray[0] = currentDataTable.Columns["ClientId"]; currentDataTable.PrimaryKey = primaryKeyArray; try { DataRow row = currentDataTable.Rows.Find(pCco.ID); row[0] = pCco.ID; row[1] = pCco.name; row[2] = pCco.ownIP; //write object BinaryFormatter formatter = new BinaryFormatter(); MemoryStream wrStream = new MemoryStream(); formatter.Serialize(wrStream, pCco); byte[] serInput = wrStream.ToArray(); row[3] = (Object)serInput; } catch (Exception ex) { Log.LogManager.writeLog("[DataManager:DBManager] Update of Client " + pCco.name + " in database not possible. Reason: " + ex.Message); } updateKinectObjectInDB(currentDataTable); if (!recievedFromClient) { OnClientUpdatedEvent.BeginInvoke(pCco, null, null); } }
/// <summary> /// constructor, loads the current config file /// </summary> public ConfigManager() { try { if (checkForConfigFile(configFilePath + configFileName)) { _ClientConfigObject = loadConfigFromFile(configFilePath + configFileName); LogManager.writeLog("[ConfigManager] Config loaded from file"); } else { _ClientConfigObject = ClientConfigObject.createDefaultConfig(); //_ClientConfigObject.clientConnectionConfig.targetIP = "localhost:8999"; //ToDo: GATEWAY LogManager.writeLog("[ConfigManager] Default config loaded"); } } catch (Exception e) { LogManager.writeLog("[ConfigManager] " + e.ToString()); _ClientConfigObject = ClientConfigObject.createDefaultConfig(); //_ClientConfigObject.clientConnectionConfig.targetIP = "localhost:8999"; } saveConfig(); LogManager.writeLog("[ConfigManager] Successfully initialized"); }
/// <summary> /// task function to do the request /// </summary> /// <param name="URL">target</param> /// <param name="input">object to send to</param> /// <param name="pCco">identification object</param> /// <param name="pTimeout"timeout duration></param> /// <returns></returns> private responseStruct sendRequestThread(String URL, Object input, ClientConfigObject pCco, int pTimeout) { if (URL != null) { try { // get the request stream WebRequest request = WebRequest.Create(URL); request.Method = "POST"; request.Timeout = pTimeout; Stream requestStream = request.GetRequestStream(); BinaryFormatter formatter = new BinaryFormatter(); formatter.Serialize(requestStream, input); requestStream.Close(); // response to the request WebResponse response = request.GetResponse(); StreamReader reader = new StreamReader(response.GetResponseStream()); responseStruct re = new responseStruct(); re.responseString = reader.ReadToEnd(); re.targetclient = pCco; return(re); } catch (Exception) { throw; } } responseStruct rel = new responseStruct(); rel.responseString = "REQUEST NOT RECIEVED ERROR"; rel.targetclient = pCco; return(rel); }
/// <summary> /// recieve a HelloRequest from the client /// </summary> /// <param name="pHro">the HRO</param> public void recieveHelloRequest(HelloRequestObject pHro) { Log.LogManager.writeLogDebug("[RegistrationService:RegistrationService] Hello request recieved from " + pHro.Name + " with the ID " + pHro.ID); ClientConfigObject cco = _DBManager.recieveHelloRequest(pHro); Log.LogManager.writeLogDebug("[RegistrationService:RegistrationService] Hello: CCO generated, isConnected: " + cco.clientRequestObject.isConnected); OnConfigRequestSendingEvent(cco); }
/// <summary> /// removes a client from the database /// </summary> /// <param name="pCco">the CCO</param> public void removeClientFromList(ClientConfigObject pCco) { if (pCco.clientRequestObject.isConnected) { Log.LogManager.writeLog("[Registrationservice:RegistrationService] Client " + pCco.name + " disconnected."); pCco.clientRequestObject.isConnected = false; _DBManager.updateClient(pCco, false); } }
/// <summary> /// starts a config request to change the configuration on the server /// </summary> /// <param name="clientConfigObject">the config object that is supposed to be written on the server</param> public void startConfigRequest(String pTargetIP, ClientConfigObject clientConfigObject) { //send data Task <String> t = new Task <String>(() => sendRequestThread(@"http://" + pTargetIP + @"/CONFIG", clientConfigObject, 10000)); t.ContinueWith(TaskFaultedHandler, TaskContinuationOptions.OnlyOnFaulted); t.ContinueWith(ConfigRequestSuccessfulHandler, TaskContinuationOptions.OnlyOnRanToCompletion); t.Start(); }
/// <summary> /// the regservice for the ping request event /// </summary> /// <param name="targetClient">the CCO</param> void _RegService_OnPingRequestSendingEvent(ClientConfigObject targetClient) { try { _WebserviceSender.sendPing(targetClient); } catch (Exception) { _RegService.removeClientFromList(targetClient); } }
/// <summary> /// updates the kinect status if the kinect is selected or deselected as master kinect /// </summary> /// <param name="pID"></param> /// <param name="master"></param> public void masterKinect(ClientConfigObject pCco, bool master) { pCco.clientKinectConfig.isMaster = master; if (pCco.clientKinectConfig.isMaster) { Log.LogManager.writeLog("[DataManager:DataManager] Client " + pCco.name + " is now the master Kinect."); } _DBManager.updateClient(pCco, true); }
/// <summary> /// loads a config object from the configfile /// </summary> /// <param name="inputPath">config file path</param> /// <returns>config object</returns> static ClientConfigObject loadConfigFromFile(String inputPath) { FileStream stream = new FileStream(inputPath, FileMode.Open); BinaryFormatter formatter = new BinaryFormatter(); ClientConfigObject _returnObject = (ClientConfigObject)formatter.Deserialize(stream); stream.Close(); _returnObject.ownIP = getOwnIP(); return(_returnObject); }
/// <summary> /// sends the shutdown command to a client /// </summary> /// <param name="pCco">the client config object</param> public void sendShutdown(ClientConfigObject pCco) { Task <responseStruct> t = new Task <responseStruct>(() => sendRequestThread( @"http://" + pCco.ownIP + ":" + pCco.clientConnectionConfig.listeningPort + @"/SHUTDOWN", String.Empty, pCco, 10000)); // if the task fails t.ContinueWith(TaskFaultedHandler, TaskContinuationOptions.OnlyOnFaulted); t.Start(); }
/// <summary> /// gets fired when the server recieves a config request from the client /// </summary> /// <param name="message">the stream</param> /// <returns>a status message</returns> public String responseConfig(Stream message) { // deserialize BinaryFormatter formatter = new BinaryFormatter(); ClientConfigObject cco = (ClientConfigObject)formatter.Deserialize(message); // fire the event OnConfigRequestEvent.BeginInvoke(cco, null, null); // feedback for the client return("CONFIG RECIEVED"); }
/// <summary> /// sends a new config to a client /// </summary> /// <param name="pCco">the config object</param> public void sendConfig(ClientConfigObject pCco) { // send the CCO Task <responseStruct> t = new Task <responseStruct>(() => sendRequestThread( @"http://" + pCco.ownIP + ":" + pCco.clientConnectionConfig.listeningPort + @"/CONFIG", pCco, pCco, 10000)); // if the task fails t.ContinueWith(TaskFaultedHandler, TaskContinuationOptions.OnlyOnFaulted); t.Start(); }
/// <summary> /// saves the config to a file /// </summary> /// <param name="inputObject">the config object to save</param> /// <param name="configFilePath">the filepath</param> /// <param name="configFileName">the filename</param> static void saveConfigToFile(ClientConfigObject inputObject, String configFilePath, String configFileName) { BinaryFormatter formatter = new BinaryFormatter(); if (!checkForConfigFile(configFilePath + configFileName)) { Directory.CreateDirectory(configFilePath); } FileStream stream = new FileStream(configFilePath + configFileName, FileMode.Create); formatter.Serialize(stream, inputObject); stream.Flush(); stream.Close(); }
/// <summary> /// load a default config for the client /// </summary> /// <returns>a default config object</returns> public static ServerConfigObject GetDefaultConfig() { return(new ServerConfigObject() { ownIP = ClientConfigObject.getOwnIP(), gatewayAddress = String.Empty, signalrAddress = String.Empty, keepAliveInterval = 5000, listeningPort = 8999, debug = true, serverAlgorithmConfig = new ServerAlgorithmConfigObject() { downsamplingFactor = 0.005f, amountOfFrames = 10, ICP_perform = false, ICP_indis = -1, euclidean_ExtractionRadius = 0.1f, euclidean_MinimumVolume = 1, planar_Iterations = 10000, planar_ThresholdDistance = 0.05f, useAlgorithm = Algorithms.ConvexConcavEnsembled, calibratedPlanes = new List <DataIntegration.PlaneModel>(), calibratedObjects = new List <DataIntegration.PointCloud>(), planar_planeComparisonVarianceThreshold = 0.1f, concav_angleThreshold = 90, correctionValue = 0 }, serverKinectFusionConfig = new ServerKinectFusionConfigObject() { ProcessorType = Microsoft.Kinect.Fusion.ReconstructionProcessor.Cpu, DeviceToUse = -1, AutoResetReconstructionWhenLost = true, MaxTrackingErrors = 100, depthHeight = 424, depthWidth = 512, minDepthClip = FusionDepthProcessor.DefaultMinimumDepth, maxDepthClip = FusionDepthProcessor.DefaultMaximumDepth, translateResetPoseByMinDepthThreshold = true, VoxelsPerMeter = 32, VoxelResolutionX = 256, VoxelResolutionY = 256, VoxelResolutionZ = 256, integrationWeight = FusionDepthProcessor.DefaultIntegrationWeight, iterationCount = FusionDepthProcessor.DefaultAlignIterationCount }, calibratedContainers = new List <ContainerConfigObject>() }); }
/// <summary> /// mute the selected client /// </summary> /// <param name="pID">the ID of the client</param> /// <param name="mute">the new mute status</param> public void muteClient(int pID, bool mute) { ClientConfigObject cco = _DBManager.getCcoByID(pID); cco.clientRequestObject.isMuted = mute; if (cco.clientRequestObject.isMuted) { Log.LogManager.writeLog("[DataManager:DataManager] Client " + cco.name + " has been muted."); } else { Log.LogManager.writeLog("[DataManager:DataManager] Client " + cco.name + " has been unmuted."); } _DBManager.updateClient(cco, true); }
private void _ButtonSettings_Click(object sender, RoutedEventArgs e) { //fetch CCO data ConnectionStatusListviewItem obj = ((FrameworkElement)sender).DataContext as ConnectionStatusListviewItem; List <ClientConfigObject> connectedClients = _DataManager.getCurrentKinectClients(); ClientConfigObject clientConfig = connectedClients.Find(t => t.ID == obj.ID); //create settings window if (lastActiveSettingsWindow == null || !lastActiveSettingsWindow.IsLoaded) { lastActiveSettingsWindow = new ClientSettingsWindow(clientConfig); lastActiveSettingsWindow.OnConfigChangeEvent += lastActiveSettingsWindow_OnConfigChangeEvent; } UpdateClientConnectionSatus(); lastActiveSettingsWindow.Show(); }
/// <summary> /// shutdown selected client /// </summary> /// <param name="pID">the ID of the client</param> public void shutdownClient(int pID) { ClientConfigObject cco = _DBManager.getCcoByID(pID); if (cco.clientRequestObject.isConnected == true) { cco.clientRequestObject.isConnected = false; Log.LogManager.writeLog("[DataManager:DataManager] Client " + cco.name + " has been shutdown."); } else { cco.clientRequestObject.isConnected = true; Log.LogManager.writeLog("[DataManager:DataManager] Attempting to start Client " + cco.name + "."); } _Webservice.sendShutdownToClient(cco); _DBManager.updateClient(cco, false); }
/// <summary> /// the selection if the kinect is the master kinect for the alignment of the pictures /// </summary> /// <param name="sender"></param> /// <param name="e"></param> private void _CheckboxMaster_Checked(object sender, RoutedEventArgs e) { ConnectionStatusListviewItem obj = ((FrameworkElement)sender).DataContext as ConnectionStatusListviewItem; List <ClientConfigObject> connectedClients = _DataManager.getCurrentKinectClients(); ClientConfigObject clientConfig = connectedClients.Find(t => t.ID == obj.ID); // resets all other kinects foreach (ClientConfigObject cco in connectedClients) { if (cco.ID == clientConfig.ID) { _DataManager.masterKinect(cco, true); masterSet = true; } else { _DataManager.masterKinect(cco, false); } } UpdateClientConnectionSatus(); }
/// <summary> /// get the client list from the database /// </summary> /// <returns>a list with all CCOs</returns> public List <ClientConfigObject> recieveClientList() { DataTable currentDataTable = getClientDataTable(); DataColumn[] primaryKeyArray = new DataColumn[1]; primaryKeyArray[0] = currentDataTable.Columns["ClientId"]; currentDataTable.PrimaryKey = primaryKeyArray; List <ClientConfigObject> retList = new List <ClientConfigObject>(); foreach (DataRow r in currentDataTable.Rows) { //get object from DB MemoryStream memStream = new MemoryStream((byte[])r[3]); BinaryFormatter formatter = new BinaryFormatter(); ClientConfigObject cco = (ClientConfigObject)formatter.Deserialize(memStream); memStream.Close(); retList.Add(cco); } return(retList); }
/// <summary> /// returns a CCO based on the ID /// </summary> /// <param name="pID">the client ID</param> /// <returns>the CCO</returns> public ClientConfigObject getCcoByID(int pID) { DataTable currentDataTable = getClientDataTable(); DataColumn[] primaryKeyArray = new DataColumn[1]; primaryKeyArray[0] = currentDataTable.Columns["ClientId"]; currentDataTable.PrimaryKey = primaryKeyArray; try { //get object from DB MemoryStream memStream = new MemoryStream((byte[])currentDataTable.Rows.Find(pID)[3]); BinaryFormatter formatter = new BinaryFormatter(); ClientConfigObject cco = (ClientConfigObject)formatter.Deserialize(memStream); memStream.Close(); return(cco); } catch (Exception ex) { Log.LogManager.writeLog("[DataManager:DBManager] " + ex.Message); } return(null); }
/// <summary> /// constructor of the window /// </summary> /// <param name="pCco">the config to be changed</param> public ClientSettingsWindow(ClientConfigObject pCco) { InitializeComponent(); currentConfig = pCco; loadConfigData(); }
/// <summary> /// updates a CCO object in the data base /// </summary> /// <param name="config">the CCO</param> private void lastActiveSettingsWindow_OnConfigChangeEvent(ClientConfigObject config) { _DataManager.UpdateClient(config); }
/// <summary> /// the shutdown call for the client /// </summary> /// <param name="pCco">the CCO</param> public void sendShutdownToClient(ClientConfigObject pCco) { _WebserviceSender.sendShutdown(pCco); }
/// <summary> /// the transport of the config to the client /// </summary> /// <param name="pCco">the CCO</param> public void sendConfigToClient(ClientConfigObject pCco) { _WebserviceSender.sendConfig(pCco); }
/// <summary> /// new config recieved from client /// </summary> /// <param name="pCco">the CCO</param> public void receiveConfigObject(ClientConfigObject pCco) { Log.LogManager.writeLog("[RegistrationService:RegistrationService] New configuration recieved from " + pCco.name); _DBManager.updateClient(pCco, true); }
/// <summary> /// give the DBManager the ConfigRequestSend event /// </summary> /// <param name="pCco">the CCO</param> void _DBManager_OnClientUpdatedEvent(ClientConfigObject pCco) { OnConfigRequestSendingEvent(pCco); }
/// <summary> /// the scan request for the clients /// </summary> /// <param name="pCco">the CCO</param> public void sendScanRequestToClient(ClientConfigObject pCco) { _WebserviceSender.sendScanRequest(pCco); }
/// <summary> /// updates the current config and saves it to a file /// </summary> /// <param name="inputConfig">the config object recieved from the server</param> public void writeConfig(ClientConfigObject inputConfig) { _ClientConfigObject = inputConfig; saveConfig(); }
/// <summary> /// the webservice contract for the config objects /// </summary> /// <param name="EventArgs">the CCO</param> void ServerWebserviceContract_OnConfigRequestEvent(ClientConfigObject EventArgs) { _RegService.receiveConfigObject(EventArgs); }
/// <summary> /// creates a new data package to be filled with data /// </summary> /// <param name="pCco">the ClientConfigObject with the configuration data</param> internal void initializeDataPackage(ClientConfigObject pCco) { currentPackage = new KinectDataPackage(pCco); dataSent = false; acceptsData = true; }