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));
}
}
