public Query(ServerConnectionSettings settings, string serverName, string databaseName, string sql) { _settings = settings; _serverName = serverName; _databaseName = databaseName; _sql = sql; }
private void setExtensionSynatx(string fileName, ServerConnectionSettings cn) { _view.tslFileName.Text = fileName; if (fileName.ToUpperInvariant().EndsWith(".CS", StringComparison.OrdinalIgnoreCase)) { setSyntax("CSharp"); } else if (fileName.ToUpperInvariant().EndsWith(".VB", StringComparison.OrdinalIgnoreCase)) { setSyntax("VB.NET"); } else if (cn != null) { if (cn.ServerVersion == ServerVersionId.MySql_5) { setSyntax("MySQL_SQL"); } else if (cn.ServerVersion == ServerVersionId.Oracle_10) { setSyntax("Oracle_SQL"); } else { setSyntax("SQLServer2K_SQL"); } } else { setSyntax("SQLServer2K_SQL"); } }
public IDatabaseManager GetDatabaseManager(ServerConnectionSettings settings) { if (settings == null) { throw new ArgumentNullException("settings"); } ServerVersionId version = settings.ServerVersion; IDatabaseManager dbMan; //Export<IDatabaseManager> foreach (var expmanager in DbManagers) { string dbVersion = expmanager.Metadata.DatabaseVersion; // string dbVersion = ServerVersionMetaData.GetMetadataString(expmanager, "DatabaseVersion"); // IDatabaseManager manager = expman.GetExportedObject(); if (dbVersion == version.VersionId) { dbMan = expmanager.Value; dbMan.Settings = settings; return(dbMan); } } throw new SQL8rException(string.Format("DbManager not loaded: {0}", version)); }
public void CreateConnection() { startMenu.ShowConnectingCanvas(); statusText.text = "Connecting to Server..."; ServerConnectionSettings.SetServerConnectionSettings(); PhotonNetwork.ConnectUsingSettings(); }
private void addViewsNode(DatabaseNode parentNode, ServerConnectionSettings settings) { var viewsNode = new ViewsNode(settings.ServerVersion); viewsNode.Nodes.Override.Sort = SortType.Ascending; parentNode.Nodes.Add(viewsNode); }
public void AddKnownServer(ServerConnectionSettings settings, bool connect) { if (addKnownServerInternal(settings, connect)) { _knownServers.Add(settings); } }
private void btnTest_Click(object sender, EventArgs e) { var settings = new ServerConnectionSettings(getSelectedServerVersion(), _view.txtServer.Text, _view.txtDatabase.Text, _view.chkWindowsAuthentication.Checked, _view.txtUser.Text, _view.txtPassword.Text); try { Cursor.Current = Cursors.WaitCursor; var fac = DatabaseManagerFactory.Instance; IDatabaseManager man = fac.GetDatabaseManager(settings); Exception ex = man.TestConnection(); if (ex != null) { showStatusBarMessage(ex.Message, ex); } else { showStatusBarMessage("Success", null); } } finally { Cursor.Current = Cursors.Default; } }
private void tsbExecuteSelected_DropDownOpened(object sender, EventArgs e) { ServerConnectionSettings scs = getCurrentConnection(); if (scs != null) { _view.tsbExecuteOnCurrentConnection.Enabled = true; _view.tsbExecuteOnCurrentConnection.ToolTipText = scs.GetConnectionString(); } else { _view.tsbExecuteOnCurrentConnection.Enabled = false; } _view.tsbExplorerConnections.DropDownItems.Clear(); IList <ServerNode> servers = MainPresenter.Instance.GetServerNodes(); if (servers.Count > 0) { foreach (ServerNode sn in servers) { ToolStripItem item = _view.tsbExplorerConnections.DropDownItems.Add(sn.ServerObject.Name); item.Tag = sn.ServerObject.ServerConnection; item.Click += executeOnConnection_Click; item.ToolTipText = sn.ServerObject.ServerConnection.GetConnectionString(); } } else { ToolStripItem item = _view.tsbExplorerConnections.DropDownItems.Add("<none>"); item.Click += btnExecuteOnNewConnection_Click; } }
public void SetNewHomeServer(string backendServerSystemId) { ServiceRegistration.Get<ILogger>().Info("ServerConnectionManager: Attaching to MediaPortal backend server '{0}'", backendServerSystemId); ServiceRegistration.Get<ILogger>().Debug("ServerConnectionManager: Stopping to watch for MediaPortal servers"); lock (_syncObj) if (_serverWatcher != null) { _serverWatcher.Stop(); _serverWatcher = null; } ServiceRegistration.Get<ILogger>().Debug("ServerConnectionManager: Building UPnP control point for communication with the new home server"); UPnPClientControlPoint cp; lock (_syncObj) cp = _controlPoint; if (cp != null) cp.Stop(); // Must be outside the lock - sends messages lock (_syncObj) { ISettingsManager settingsManager = ServiceRegistration.Get<ISettingsManager>(); ServerConnectionSettings settings = settingsManager.Load<ServerConnectionSettings>(); // Here, we only set the system ID of the new home server. The server's system ID will remain in the settings // until method SetNewHomeServer is called again. settings.HomeServerSystemId = backendServerSystemId; settingsManager.Save(settings); _controlPoint = BuildClientControlPoint(backendServerSystemId); } _controlPoint.Start(); // Outside the lock ServerConnectionMessaging.SendServerConnectionStateChangedMessage(ServerConnectionMessaging.MessageType.HomeServerAttached); }
public ServerConnectionSettings GetConnection() { var settings = new ServerConnectionSettings(getSelectedServerVersion(), _view.txtServer.Text, _view.txtDatabase.Text, _view.chkWindowsAuthentication.Checked, _view.txtUser.Text, _view.txtPassword.Text); return(settings); }
public HubManager(ServerConnectionSettings connectionSettings) { _connection = new HubConnectionBuilder() .WithUrl($"{connectionSettings.ServerURL}/notification") .WithAutomaticReconnect() .Build(); _connection.On <string>("botnewjobnotification", (agentId) => JobNotificationReceived?.Invoke(agentId)); }
/// <summary> /// When a home server is connected, we store the connection data of the server to be able to /// provide the home server's data also when the connection is down. We'll refresh the data each time /// the server is connected to track changes in the server's location, name, ... /// </summary> protected static void SaveLastHomeServerData(ServerDescriptor serverDescriptor) { ISettingsManager settingsManager = ServiceRegistration.Get<ISettingsManager>(); ServerConnectionSettings settings = settingsManager.Load<ServerConnectionSettings>(); settings.LastHomeServerName = serverDescriptor.ServerName; settings.LastHomeServerSystem = serverDescriptor.GetPreferredLink(); settingsManager.Save(settings); }
public ServerResponse DisconnectFromServer(ServerConnectionSettings settings) { // User validation check if (!ServiceController.IsValidUser(settings.DNSHost, settings.UserName)) { return(InvalidUserResponse()); } return(AgentsManager.GetAgent(settings.UserName).Disconnect(settings)); }
private void executeCode(ServerConnectionSettings cn, string language, string code, string fileName) { //var dnh = new DotNetManagerFront(); ICodeManager man = CodeManagerFactory.Instance.GetCodeManager(); DataSet ds = man.CompileAndRun(language, code); if (ds != null) { var query = new Query(cn, cn.ServerName, cn.DatabaseName, code, ds.Tables[0]); _parentPresenter.OpenCode(query, fileName); } }
public void LoadKnownServers() { var sh = new SettingsIO(); IList <ServerConnectionSettings> knownServers = sh.LoadKnownServers(); removeKnownServers(); for (int i = 0; i < knownServers.Count; i++) { ServerConnectionSettings settings = knownServers[i]; AddKnownServer(settings, false); } }
public async void ExecuteAttendedTask(string projectPackagePath, ServerConnectionSettings settings, bool isServerAutomation = false) { try { var task = _pipeProxy.ExecuteAttendedTask(projectPackagePath, settings, isServerAutomation); await task.ContinueWith(e => TaskFinishedEvent?.Invoke(this, task.Result)); } catch (TimeoutException ex) { throw ex; } }
public ServerResponse Connect(ServerConnectionSettings connectionSettings) { // Initialize File Logger for Debug Purpose _fileLogger.Initialize(new EnvironmentSettings().GetEnvironmentVariablePath(connectionSettings.DNSHost, connectionSettings.UserName)); // Log Event _fileLogger.LogEvent("Connect", "Attempt to connect to the Server"); _connectionSettingsManager.ConnectionSettings = connectionSettings; // Initialize AuthAPIManager _authAPIManager.Initialize(_connectionSettingsManager.ConnectionSettings); try { // Authenticate Agent _authAPIManager.GetToken(); // API Call to Connect var connectAPIResponse = AgentsAPIManager.ConnectAgent(_authAPIManager, _connectionSettingsManager.ConnectionSettings = _authAPIManager.ConnectionSettings); // Update Server Settings _connectionSettingsManager.ConnectionSettings.ServerConnectionEnabled = true; _connectionSettingsManager.ConnectionSettings.AgentId = connectAPIResponse.Data.AgentId.ToString(); _connectionSettingsManager.ConnectionSettings.AgentName = connectAPIResponse.Data.AgentName.ToString(); // Start Server Communication StartServerCommunication(); // Send Response to Agent return(new ServerResponse(_connectionSettingsManager.ConnectionSettings, connectAPIResponse.StatusCode.ToString())); } catch (Exception ex) { // Update Server Settings _connectionSettingsManager.ConnectionSettings.ServerConnectionEnabled = false; _connectionSettingsManager.ConnectionSettings.AgentId = string.Empty; _connectionSettingsManager.ConnectionSettings.AgentName = string.Empty; string errorMessage; var errorCode = ex.GetType().GetProperty("ErrorCode")?.GetValue(ex, null)?.ToString() ?? string.Empty; errorMessage = ex.GetType().GetProperty("ErrorContent")?.GetValue(ex, null)?.ToString() ?? ex.Message; // Log Event (Error) _fileLogger.LogEvent("Connect", $"Error occurred while connecting to the Server; " + $"Error Code = {errorCode}; Error Message = {errorMessage}", LogEventLevel.Error); // Send Response to Agent return(new ServerResponse(null, errorCode, errorMessage)); } }
private string GetExecutionParams(string mainScriptFilePath, ServerConnectionSettings settings, List <string> projectDependencies) { var executionParams = new JobExecutionParams() { MainFilePath = mainScriptFilePath, ProjectDirectoryPath = Path.GetDirectoryName(mainScriptFilePath), ProjectDependencies = projectDependencies, ServerConnectionSettings = settings }; var paramsJsonString = JsonConvert.SerializeObject(executionParams); return(DataFormatter.CompressString(paramsJsonString)); }
public AttendedExecution() { InitializeComponent(); _publishedProjectsWatcher = new FileSystemWatcher(); _connectionSettings = new ServerConnectionSettings() { SinkType = SinkType.File.ToString(), TracingLevel = LogEventLevel.Information.ToString(), LoggingValue1 = Path.Combine(new EnvironmentSettings().GetEnvironmentVariablePath(), "Logs", "Attended Execution", "log.txt"), DNSHost = SystemInfo.GetUserDomainName(), UserName = Environment.UserName }; }
public bool ExecuteTask(string projectPackage, ServerConnectionSettings settings, bool isServerAutomation) { if (!_executionManager.IsEngineBusy) { bool isSuccessful; string projectDirectoryPath, configFilePath, mainScriptFilePath; projectDirectoryPath = configFilePath = mainScriptFilePath = string.Empty; try { _executionManager.SetEngineStatus(true); if (isServerAutomation) { // projectPackage is "Name" of the Project Package here string filter = $"originalPackageName eq '{projectPackage}'"; var automation = AutomationsAPIManager.GetAutomations(_authAPIManager, filter).Data?.Items.FirstOrDefault(); mainScriptFilePath = AutomationManager.DownloadAndExtractAutomation(_authAPIManager, automation, string.Empty, settings.DNSHost, settings.UserName, out configFilePath); } else { // projectPackage is "Path" of the Project Package here mainScriptFilePath = AutomationManager.GetMainScriptFilePath(projectPackage, out configFilePath); } projectDirectoryPath = Path.GetDirectoryName(mainScriptFilePath); NugetPackageManager.InstallProjectDependencies(configFilePath, settings.DNSHost, settings.UserName); var assembliesList = NugetPackageManager.LoadPackageAssemblies(configFilePath, settings.DNSHost, settings.UserName); RunAttendedAutomation(mainScriptFilePath, settings, assembliesList); isSuccessful = true; } catch (Exception) { isSuccessful = false; } finally { // Delete Project Directory if (Directory.Exists(projectDirectoryPath)) { Directory.Delete(projectDirectoryPath, true); } _executionManager.SetEngineStatus(false); } return(isSuccessful); } return(false); }
private bool addKnownServerInternal(ServerConnectionSettings settings, bool connect) { var btSvr = new ButtonTool(settings.ServerName); if (!_view.tbManager.Tools.Exists(btSvr.Key)) { btSvr.SharedProps.Caption = settings.ServerName; btSvr.SharedProps.ToolTipTitle = string.Format("{0} - ({1})", settings.ServerName, settings.ServerVersion); btSvr.SharedProps.AppearancesSmall.Appearance.Image = 6; btSvr.ToolClick += RibbonEventHandlers.btSvr_ToolClick; btSvr.Tag = settings; _view.tbManager.Tools.Add(btSvr); RibbonGroup rgKnownServers = _view.tbManager.Ribbon.Tabs[0].Groups[1]; var btRemoveKnownServer = (PopupMenuTool)_view.tbManager.Ribbon.Tabs[0].Groups[2].Tools[0]; int pos = rgKnownServers.Tools.Add(btSvr); ToolBase t = rgKnownServers.Tools[pos]; t.Tag = settings; var btRemoveSvr = new ButtonTool("Remove" + btSvr.Key); btRemoveSvr.SharedProps.Caption = btSvr.SharedProps.Caption; btRemoveSvr.Tag = btSvr; _view.tbManager.Tools.Add(btRemoveSvr); int id = btRemoveKnownServer.Tools.Add(btRemoveSvr); btRemoveKnownServer.Tools[id].Tag = btSvr; int nbrOfTools = rgKnownServers.Tools.Count; if (nbrOfTools < 10) { t.SharedProps.Shortcut = (Shortcut)Enum.Parse(typeof(Shortcut), string.Format("Ctrl{0}", nbrOfTools)); t.SharedProps.ToolTipText = string.Format("Shortcut {0}", t.SharedProps.Shortcut); } if (connect) { RibbonEventHandlers.btSvr_ToolClick(btSvr, new ToolClickEventArgs(btSvr, null)); } return(true); } else { MessageBox.Show("Server already added", DialogHelper.Instance.GetApplicationName()); return(false); } }
public void DetachFromHomeServer() { ISettingsManager settingsManager = ServiceRegistration.Get <ISettingsManager>(); ServerConnectionSettings settings = settingsManager.Load <ServerConnectionSettings>(); ServiceRegistration.Get <ILogger>().Info("ServerConnectionManager: Detaching from home server '{0}'", settings.HomeServerSystemId); UPnPServerControllerServiceProxy sc = ServerControllerServiceProxy; if (sc != null) { try { sc.AttachedClientsChanged -= OnAttachedClientsChanged; sc.ConnectedClientsChanged -= OnConnectedClientsChanged; } catch (Exception e) { ServiceRegistration.Get <ILogger>().Warn("ServerConnectionManager: Error detaching from home server '{0}'", e, HomeServerSystemId); } } ServiceRegistration.Get <ILogger>().Debug("ServerConnectionManager: Closing server connection"); UPnPClientControlPoint cp; lock (_syncObj) cp = _controlPoint; if (cp != null) { cp.Stop(); // Must be outside the lock - sends messages } lock (_syncObj) { settings.HomeServerSystemId = null; settings.LastHomeServerName = null; settings.LastHomeServerSystem = null; settingsManager.Save(settings); _controlPoint = null; } ServerConnectionMessaging.SendServerConnectionStateChangedMessage(ServerConnectionMessaging.MessageType.HomeServerDetached); ServiceRegistration.Get <ILogger>().Debug("ServerConnectionManager: Starting to watch for MediaPortal servers"); if (_serverWatcher == null) { lock (_syncObj) _serverWatcher = BuildServerWatcher(); _serverWatcher.Start(); // Outside the lock } }
public async Task <bool> ExecuteAttendedTask(string projectPackage, ServerConnectionSettings settings, bool isServerAutomation) { var task = Task.Factory.StartNew(() => { // User validation check if (!ServiceController.IsValidUser(settings.DNSHost, settings.UserName)) { return(false); } return(AgentsManager.GetAgent(settings.UserName).ExecuteAttendedTask(projectPackage, settings, isServerAutomation)); }); return(await task.ConfigureAwait(false)); }
void btnDrop_Click(object sender, EventArgs e) { OpenFileDialog open = DialogFactory.Instance.GetOpenSQLiteDialog(); if (open.ShowDialog() == DialogResult.OK) { _view.txtDatabase.Text = open.FileName; _view.ActiveControl = _view.txtDatabase; _view.ActiveControl = _view.btnSelect; var settings = new ServerConnectionSettings(_currentVersion, ""); IDatabaseManager manager = DatabaseManagerFactory.Instance.GetDatabaseManager(settings); manager.DropDatabase(open.FileName); } }
void btnCreate_Click(object sender, EventArgs e) { SaveFileDialog create = DialogFactory.Instance.GetCreateSQLiteDialog(); if (create.ShowDialog() == DialogResult.OK) { _view.txtDatabase.Text = create.FileName; _view.ActiveControl = _view.txtDatabase; _view.ActiveControl = _view.btnSelect; var settings = new ServerConnectionSettings(_currentVersion, ""); IDatabaseManager manager = DatabaseManagerFactory.Instance.GetDatabaseManager(settings); manager.CreateDatabase(create.FileName, true); } }
private void RunAttendedAutomation(string mainScriptFilePath, ServerConnectionSettings settings, List <string> projectDependencies) { var executionParams = GetExecutionParams(mainScriptFilePath, settings, projectDependencies); var userInfo = new MachineCredential { Domain = settings.DNSHost, UserName = settings.UserName }; var executorPath = Directory.GetFiles(AppDomain.CurrentDomain.BaseDirectory, "OpenBots.Executor.exe").FirstOrDefault(); var cmdLine = $"\"{executorPath}\" \"{executionParams}\""; // launch the Executor ProcessLauncher.PROCESS_INFORMATION procInfo; ProcessLauncher.LaunchProcess(cmdLine, userInfo, out procInfo); }
private void executeQuery(ServerConnectionSettings cn, string fileName) { string sql; if (_view.txtEditor.Selection.IsValid) { sql = _view.txtEditor.Selection.Text; } else { sql = _view.txtEditor.Document.Text; } //string fileName = _view.tslFileName.Text; executeQuery2(cn, sql, fileName); }
public bool OpenQuery(Query viewQ, string fileName) { if (closeCurrentFile()) { _lastConnection = viewQ.ServerConnection; setExtensionSynatx(fileName, _lastConnection); _view.txtEditor.Document.Tag = viewQ; _view.txtEditor.Document.Text = viewQ.Sql; _view.tslFileName.Text = fileName; _view.Text = fileName; return(true); } return(false); }
private void executeQuery2(ServerConnectionSettings cn, string sql, string fileName) { if (cn != null) { _lastConnection = cn; if (!string.IsNullOrEmpty(sql.Trim())) { string ext = getExtension(fileName); if (ext.Equals("CS") || ext.Equals("VB")) { string code = sql; string language = ext; executeCode(cn, language, code, fileName); } else { var fac = DatabaseManagerFactory.Instance; IDatabaseManager man = fac.GetDatabaseManager(cn); try { DataSet ds = man.ExecuteQuery(cn.ServerName, cn.DatabaseName, sql); _parentPresenter.OpenQuery(ds, "ad hoc query"); MainPresenter.Instance.SetError("Query executed without errors"); } catch (SqlException ex) { _view.txtEditor.GotoLine(ex.LineNumber - 1); _view.txtEditor.Caret.MoveHome(false); _view.txtEditor.Caret.MoveEnd(true); // _view.txtEditor.Selection.Bounds.LastRow = _view.txtEditor.Selection.Bounds.FirstRow + 1; MainPresenter.Instance.SetError(ex.Message); } } } else { MainPresenter.Instance.SetError("Nothing to execute"); } } else { MainPresenter.Instance.SetError("Query has no connection"); } }
public ServerResponse PingServer(ServerConnectionSettings serverSettings) { try { _authAPIManager.Initialize(serverSettings); var serverIP = _authAPIManager.Ping(); _authAPIManager.UnInitialize(); return(new ServerResponse(serverIP)); } catch (Exception ex) { var errorCode = ex.GetType().GetProperty("ErrorCode")?.GetValue(ex, null)?.ToString() ?? string.Empty; var errorMessage = ex.GetType().GetProperty("ErrorContent")?.GetValue(ex, null)?.ToString() ?? ex.Message; // Send Response to Agent return(new ServerResponse(null, errorCode, errorMessage)); } }