public void DisposedConnectionsAreRemovedFromActive_WhenMultipleConnectionsAreActive()
        {
            var serviceEndpoint   = new ServiceEndPoint("https://localhost:42", Certificates.TentacleListeningPublicThumbprint);
            var connectionManager = new ConnectionManager();

            //do it twice because this bug only triggers on multiple enumeration, having 1 in the collection doesn't trigger the bug
            connectionManager.AcquireConnection(connectionFactory, serviceEndpoint, new InMemoryConnectionLog(serviceEndpoint.ToString()));
            connectionManager.AcquireConnection(connectionFactory, serviceEndpoint, new InMemoryConnectionLog(serviceEndpoint.ToString()));

            connectionManager.Disconnect(serviceEndpoint, null);
            connectionManager.GetActiveConnections(serviceEndpoint).Should().BeNullOrEmpty();
        }
示例#2
0
        private void LoadContainers(ConnectionManagerElement cme)
        {
            this.cmbContainerID.Items.Clear();

            ConnectionManagerMappingEventArgs args = new ConnectionManagerMappingEventArgs();

            args.ConnectionManagerElement = cme;
            ConnectionManager cm = this.GetSelectedConnectionManager(this, args);

            try
            {
                Microsoft.Samples.DataServices.Connectivity.Connection conn = cm.AcquireConnection(null) as Connection;

                if (conn != null)
                {
                    Microsoft.Samples.DataServices.Connectivity.Container[] conts = conn.GetContainers();

                    if (conts != null)
                    {
                        foreach (Microsoft.Samples.DataServices.Connectivity.Container cont in conts)
                        {
                            this.cmbContainerID.Items.Add(cont.Id);
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                MessageBox.Show(ex.Message, "Error", MessageBoxButtons.OK, MessageBoxIcon.Error,
                                MessageBoxDefaultButton.Button1);
                this.cmbContainerID.Items.Clear();
                this.btnNewContainer.Enabled = false;
            }
        }
示例#3
0
        public override DTSExecResult Execute(Connections connections, VariableDispenser variableDispenser, IDTSComponentEvents componentEvents, IDTSLogging log, object transaction)
        {
            ConnectionManager cSSH = getConnectionManager(connections, _SSHconnMgrName);
            List <KeyValuePair <string, string> > connParams = (List <KeyValuePair <string, string> >)cSSH.AcquireConnection(transaction);

            string host     = connParams.Find(t => t.Key == "Host").Value;
            string username = connParams.Find(t => t.Key == "Username").Value;
            string password = connParams.Find(t => t.Key == "Password").Value;
            int    port     = Convert.ToInt32(connParams.Find(t => t.Key == "Port").Value);

            if (_operation == SSHFTPOperation.SendFiles)
            {
                ConnectionManager       cSend      = getConnectionManager(connections, _sendFilesSourceConnectionManagerName);
                string                  sourceFile = cSend.AcquireConnection(transaction).ToString();
                SshTransferProtocolBase sshCp;
                sshCp          = new Sftp(host, username);
                sshCp.Password = password;
                string localFile  = sourceFile;
                string remoteFile = getRemotePathAndFile(_sendFilesDestinationDirectory, Path.GetFileName(sourceFile));
                try
                {
                    sshCp.Connect();
                    sshCp.Put(localFile, remoteFile);
                }
                catch
                {
                    throw;
                }
                finally
                {
                    sshCp.Close();
                }
            }
            if (_operation == SSHFTPOperation.ReceiveFiles)
            {
                ConnectionManager       cReceive             = getConnectionManager(connections, _receiveFilesDestinationConnectionManagerName);
                string                  destinationDirectory = cReceive.AcquireConnection(transaction).ToString();
                SshTransferProtocolBase sshCp;
                sshCp          = new Sftp(host, username);
                sshCp.Password = password;
                try
                {
                    sshCp.Connect();
                    sshCp.Get(_receiveFilesSourceFile, destinationDirectory);
                }
                catch
                {
                    throw;
                }
                finally
                {
                    sshCp.Close();
                }
            }

            return(DTSExecResult.Success);
        }
        public void DisconnectDisposesActiveConnections()
        {
            var serviceEndpoint   = new ServiceEndPoint("https://localhost:42", Certificates.TentacleListeningPublicThumbprint);
            var connectionManager = new ConnectionManager();

            var activeConnection = connectionManager.AcquireConnection(connectionFactory, serviceEndpoint, new InMemoryConnectionLog(serviceEndpoint.ToString()));

            connectionManager.GetActiveConnections(serviceEndpoint).Should().OnlyContain(c => c == activeConnection);

            connectionManager.Disconnect(serviceEndpoint, new InMemoryConnectionLog(serviceEndpoint.ToString()));
            connectionManager.GetActiveConnections(serviceEndpoint).Should().BeNullOrEmpty();
        }
示例#5
0
        private SqlCommand GetSqlCommand(ConnectionManager connMan)
        {
            SqlConnection conn = null;

            conn = connMan.AcquireConnection(Transaction) as SqlConnection;

            if (conn == null)
            {
                FireError("Failed to aquire ADO.NET connection");
            }

            SqlCommand cmd = new SqlCommand(SQLCheckStatement, conn);

            return(cmd);
        }
示例#6
0
        public override void AcquireConnections(object transaction)
        {
            if (ComponentMetaData.RuntimeConnectionCollection[0].ConnectionManager != null)
            {
                //get runtime connection manager
                ConnectionManager cm = Microsoft.SqlServer.Dts.Runtime.DtsConvert.GetWrapper(ComponentMetaData.RuntimeConnectionCollection[0].ConnectionManager);
                this.OGRDataSource = cm.AcquireConnection(transaction) as DataSource;

                if (this.OGRDataSource == null)
                {
                    throw new Exception("The connection manager did not provide a valid OGR datasource");
                }
                this.isConnected = true;
            }
        }
 public override DTSExecResult Execute(Connections connections, VariableDispenser variableDispenser, IDTSComponentEvents componentEvents, IDTSLogging log, object transaction)
 {
     try
     {
         ConnectionManager cm = connections[_customSmtpConnectionID];
         SmtpClient        c  = (SmtpClient)cm.AcquireConnection(transaction);
         using (MailMessage m = new MailMessage(_expediteur, _destinataire, _objet, _message))
         {
             c.SendMailAsync(m);
         }
         return(DTSExecResult.Success);
     }
     catch (Exception e)
     {
         componentEvents.FireError(0, "Tâche Evoie Email", e.Message, "", 0);
         return(DTSExecResult.Failure);
     }
 }
示例#8
0
 /// <summary>
 /// Initializes connection used at design time
 /// </summary>
 private void InitDesignTimeConnection()
 {
     try
     {
         ConnectionManager conMgr = _connections[Constants.CONNECTION_MANAGER_OLEDB_NAME_CONFIG];
         _configConnection   = new OleDbConnection(conMgr.ConnectionString);
         ConnectionManagerId = conMgr.ID;
     }
     catch (Exception)
     {
         try
         {
             ConnectionManager conMgr = _connections[Constants.CONNECTION_MANAGER_ADO_NAME_CONFIG];
             _configConnection   = (DbConnection)conMgr.AcquireConnection(null);
             ConnectionManagerId = conMgr.ID;
         }
         catch (Exception) { }
     }
 }
        /// <summary>
        /// Called at design time and runtime. Establishes a connection using a ConnectionManager in the package.
        /// </summary>
        /// <param name="transaction">Not used.</param>
        public override void AcquireConnections(object transaction)
        {
            if (ComponentMetaData.RuntimeConnectionCollection[0].ConnectionManager != null)
            {
                ConnectionManager cm =
                    Microsoft.SqlServer.Dts.Runtime.DtsConvert.ToConnectionManager(
                        ComponentMetaData.RuntimeConnectionCollection[0].ConnectionManager);

                _connection = (Connection)cm.AcquireConnection(null);
                if ((_connection == null) || (_connection.Test() != true))
                {
                    ComponentMetaData.FireError(0, ComponentMetaData.Name, "Connection object got from connection manager is not valid", string.Empty, 0, out this._cancel);
                }
            }
            else
            {
                _connection = null;
            }
        }
示例#10
0
        public override DTSExecResult Execute(Connections connections, VariableDispenser variableDispenser, IDTSComponentEvents componentEvents, IDTSLogging log, object transaction)
        {
            Debugger.Launch();

            var           filesToTransfer = Directory.GetFiles(SourceDirectory, FileTypeFilter);
            WebHDFSClient client;

            if (filesToTransfer.Length == 0)
            {
                return(DTSExecResult.Success);
            }

            try
            {
                ConnectionManager cm = connections[this.ConnectionManagerName];
                client = cm.AcquireConnection(transaction) as WebHDFSClient;
            }
            catch (Exception)
            {
                componentEvents.FireError(0, "HDFSTask", "Unable to create HDFS Connection Manager", "", 0);
                return(DTSExecResult.Failure);
            }

            foreach (var file in filesToTransfer)
            {
                string fileName = Path.GetFileName(file);

                string remoteFileName = RemoteDirectory + "/" + fileName;

                try
                {
                    client.CreateFile(file, remoteFileName).Wait();
                }
                catch (Exception)
                {
                    componentEvents.FireError(0, "HDFSTask", "Unable to transfer file...", "", 0);
                    return(DTSExecResult.Failure);
                }
            }
            return(DTSExecResult.Success);
        }
示例#11
0
        private void btnNewContainer_Click(object sender, EventArgs e)
        {
            ConnectionManagerMappingEventArgs args = new ConnectionManagerMappingEventArgs();

            args.ConnectionManagerElement = this.cmbCM.SelectedItem as ConnectionManagerElement;
            ConnectionManager cm = this.GetSelectedConnectionManager(this, args);

            Connection conn = cm.AcquireConnection(null) as Connection;

            Microsoft.Samples.DataServices.Connectivity.Container cont = conn.CreateContainer(this.ContainerId);

            if (cont != null)
            {
                this.cmbContainerID.Items.Add(this.ContainerId);
                this.cmbContainerID.SelectedIndex = this.cmbContainerID.Items.Count - 1;

                MessageBox.Show("Created new container: " + this.ContainerId);
            }
            else
            {
                MessageBox.Show("Failed to create a new container.", "Error", MessageBoxButtons.OK,
                                MessageBoxIcon.Error, MessageBoxDefaultButton.Button1);
            }
        }
示例#12
0
        public static PackageConfigurationSetting[] GetPackageConfigurationSettings(Microsoft.SqlServer.Dts.Runtime.Configuration c, Package p, string sVisualStudioRelativePath, bool bOfflineMode)
        {
            List <PackageConfigurationSetting> list = new List <PackageConfigurationSetting>();

            if (c.ConfigurationType == DTSConfigurationType.ConfigFile || c.ConfigurationType == DTSConfigurationType.IConfigFile)
            {
                string sConfigurationString = c.ConfigurationString;
                if (c.ConfigurationType == DTSConfigurationType.IConfigFile)
                {
                    sConfigurationString = System.Environment.GetEnvironmentVariable(c.ConfigurationString);
                }

                XmlDocument dom = new XmlDocument();
                if (sConfigurationString != null)
                {
                    if (sConfigurationString.Contains("\\"))
                    {
                        dom.Load(sConfigurationString);
                    }
                    else
                    {
                        //if it's a relative file path, then try this directory first, and if it's not there, then try the path relative to the dtsx package
                        if (System.IO.File.Exists(sVisualStudioRelativePath + sConfigurationString))
                        {
                            dom.Load(sVisualStudioRelativePath + sConfigurationString);
                        }
                        else
                        {
                            dom.Load(sConfigurationString);
                        }
                    }
                    foreach (XmlNode node in dom.GetElementsByTagName("Configuration"))
                    {
                        list.Add(new PackageConfigurationSetting(node.Attributes["Path"].Value, node.SelectSingleNode("ConfiguredValue").InnerText));
                    }
                }
            }
            else if (c.ConfigurationType == DTSConfigurationType.SqlServer && !bOfflineMode) //not when in offline mode
            {
                string sConnectionManagerName;
                string sTableName;
                string sFilter;
                Microsoft.DataTransformationServices.Design.DesignUtils.ParseSqlServerConfigurationString(c.ConfigurationString, out sConnectionManagerName, out sTableName, out sFilter);

                ConnectionManager cm = p.Connections[sConnectionManagerName];
                if (cm.OfflineMode)
                {
                    return(list.ToArray());
                }

                ISessionProperties o = cm.AcquireConnection(null) as ISessionProperties;
                try
                {
                    IDBCreateCommand command = (IDBCreateCommand)o;
                    ICommandText     ppCommand;
                    Guid             IID_ICommandText = new Guid(0xc733a27, 0x2a1c, 0x11ce, 0xad, 0xe5, 0, 170, 0, 0x44, 0x77, 0x3d);
                    command.CreateCommand(IntPtr.Zero, ref IID_ICommandText, out ppCommand);
                    Guid DBGUID_DEFAULT = new Guid(0xc8b521fb, 0x5cf3, 0x11ce, 0xad, 0xe5, 0, 170, 0, 0x44, 0x77, 0x3d);
                    ppCommand.SetCommandText(ref DBGUID_DEFAULT, "select ConfiguredValue, PackagePath from " + sTableName + " Where ConfigurationFilter = '" + sFilter.Replace("'", "''") + "'");
                    IntPtr      PtrZero         = new IntPtr(0);
                    Guid        IID_IRowset     = new Guid(0xc733a7c, 0x2a1c, 0x11ce, 0xad, 0xe5, 0, 170, 0, 0x44, 0x77, 0x3d);
                    tagDBPARAMS dbParams        = null;
                    int         recordsAffected = 0;
                    object      executeResult   = null;
                    int         result          = ppCommand.Execute(PtrZero, ref IID_IRowset, dbParams, out recordsAffected, out executeResult);

                    System.Reflection.BindingFlags getmethodflags = System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.InvokeMethod | System.Reflection.BindingFlags.DeclaredOnly | System.Reflection.BindingFlags.Instance;
                    System.Reflection.BindingFlags getstaticflags = System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.GetField | System.Reflection.BindingFlags.DeclaredOnly | System.Reflection.BindingFlags.Static;
                    Type   chapterHandleType = ExpressionHighlighterPlugin.GetPrivateType(typeof(System.Data.OleDb.OleDbCommand), "System.Data.OleDb.ChapterHandle");
                    object chapterHandle     = chapterHandleType.InvokeMember("DB_NULL_HCHAPTER", getstaticflags, null, null, null);

                    System.Data.OleDb.OleDbDataReader dataReader = null;
                    dataReader = (System.Data.OleDb.OleDbDataReader) typeof(System.Data.OleDb.OleDbDataReader).GetConstructors(getmethodflags)[0].Invoke(new object[] { null, null, 0, System.Data.CommandBehavior.SingleResult });
                    IntPtr intPtrRecordsAffected = new IntPtr(-1);
                    dataReader.GetType().InvokeMember("InitializeIRowset", getmethodflags, null, dataReader, new object[] { executeResult, chapterHandle, intPtrRecordsAffected });
                    dataReader.GetType().InvokeMember("BuildMetaInfo", getmethodflags, null, dataReader, new object[] { });
                    dataReader.GetType().InvokeMember("HasRowsRead", getmethodflags, null, dataReader, new object[] { });
                    executeResult = null;

                    while (dataReader.Read())
                    {
                        list.Add(new PackageConfigurationSetting(dataReader["PackagePath"].ToString(), dataReader["ConfiguredValue"].ToString()));
                    }
                    dataReader.Close();
                }
                finally
                {
                    System.Runtime.InteropServices.Marshal.ReleaseComObject(o);
                }
            }
            else if (c.ConfigurationType == DTSConfigurationType.EnvVariable)
            {
                list.Add(new PackageConfigurationSetting(c.PackagePath, System.Environment.GetEnvironmentVariable(c.ConfigurationString)));
            }
            else if (c.ConfigurationType == DTSConfigurationType.ParentVariable || c.ConfigurationType == DTSConfigurationType.IParentVariable)
            {
                list.Add(new PackageConfigurationSetting(c.PackagePath, "")); //can't know value at design time
            }
            else if (c.ConfigurationType == DTSConfigurationType.RegEntry)
            {
                list.Add(new PackageConfigurationSetting(c.PackagePath, (string)Microsoft.Win32.Registry.GetValue("HKEY_CURRENT_USER\\" + c.ConfigurationString, "Value", "")));
            }
            else if (c.ConfigurationType == DTSConfigurationType.IRegEntry)
            {
                list.Add(new PackageConfigurationSetting(c.PackagePath, (string)Microsoft.Win32.Registry.GetValue("HKEY_CURRENT_USER\\" + System.Environment.GetEnvironmentVariable(c.ConfigurationString), "Value", "")));
            }
            return(list.ToArray());
        }
示例#13
0
        public override DTSExecResult Execute(Connections connections, VariableDispenser variableDispenser, IDTSComponentEvents componentEvents, IDTSLogging log, object transaction)
        {
            ConnectionManager conn = getCurrentConnectionManager(connections);
            List <KeyValuePair <string, string> > connParams = (List <KeyValuePair <string, string> >)conn.AcquireConnection(transaction);

            string host     = connParams.Find(t => t.Key == "Host").Value;
            string username = connParams.Find(t => t.Key == "Username").Value;
            string password = connParams.Find(t => t.Key == "Password").Value;
            int    port     = Convert.ToInt32(connParams.Find(t => t.Key == "Port").Value);

            SshExec exec = new SshExec(host, username);

            exec.Password = password;

            try
            {
                string stdOut = string.Empty;
                string stdErr = string.Empty;
                exec.Connect();
                StringReader sr = new StringReader(_commandText);
                while (true)
                {
                    string s = sr.ReadLine();
                    if (s != null && stdErr.Trim().Length == 0)
                    {
                        int res = exec.RunCommand(s, ref stdOut, ref stdErr);
                    }
                    else
                    {
                        if (stdErr.Trim().Length > 0)
                        {
                            fireError(componentEvents, stdErr);
                            return(DTSExecResult.Failure);
                        }
                        break;
                    }
                }
            }
            catch (Exception ex)
            {
                fireError(componentEvents, ex.Message);
                return(DTSExecResult.Failure);
            }
            finally
            {
                exec.Close();
            }
            return(DTSExecResult.Success);
        }
        /// <summary>
        /// Called at design time and runtime. Establishes a connection using a ConnectionManager in the package.
        /// </summary>
        /// <param name="transaction">Not used.</param>


        public override void AcquireConnections(object transaction)
        {
            if (ComponentMetaData.RuntimeConnectionCollection[0].ConnectionManager != null)
            {
                ConnectionManager connectionManager = Microsoft.SqlServer.Dts.Runtime.DtsConvert.GetWrapper(
                    ComponentMetaData.RuntimeConnectionCollection[0].ConnectionManager);

                Dictionary <string, string> connProperties = (Dictionary <string, string>)connectionManager.AcquireConnection(null);

                this.ClientID           = connProperties["ClientID"];
                this.PowerBIDataSets    = connProperties["PowerBIDataSets"];
                this.RedirectUri        = connProperties["RedirectUri"];
                this.ResourceUri        = connProperties["ResourceUri"];
                this.OAuth2AuthorityUri = connProperties["OAuth2AuthorityUri"];
                this.PowerBIDataSets    = connProperties["PowerBIDataSets"];
                this.UserName           = connProperties["UserName"];
                this.Password           = connProperties["Password"];
            }
            else
            {
                throw new Exception("Couldn't get the Power BI connection manager, ");
            }
        }