void Awake(){ instance = this; if (!PhotonNetwork.connected) PhotonNetwork.ConnectUsingSettings("v1.0"); // version of the game/demo. used to separate older clients from newer ones (e.g. if incompatible) //PhotonNetwork.playerName = PlayerPrefs.GetString("playerName", "Guest" + Random.Range(1, 9999)); }
public void Initialize(ConnectionManager connectionManager, IServiceProvider serviceProvider) { this._connectionManager = connectionManager; this._serviceProvider = serviceProvider; ConfigureControlsFromConnectionManager(); }
private static async Task RunClientAsync(Uri address, CancellationToken token) { ClientEventSource eventSource = ClientEventSource.Instance; NetNamedPipeBinding binding = new NetNamedPipeBinding(NetNamedPipeSecurityMode.None); binding.OpenTimeout = TimeSpan.FromSeconds(1.0d); binding.SendTimeout = TimeSpan.FromSeconds(1.0d); binding.ReceiveTimeout = TimeSpan.FromSeconds(1.0d); binding.CloseTimeout = TimeSpan.FromSeconds(1.0d); CalculatorChannelFactory factory = new CalculatorChannelFactory(binding, new EndpointAddress(address), eventSource); await factory.OpenAsync(); ConnectionManager<ICalculatorClientAsync> connectionManager = new ConnectionManager<ICalculatorClientAsync>(factory); using (ProxyInvoker<ICalculatorClientAsync> proxy = new ProxyInvoker<ICalculatorClientAsync>(connectionManager)) { Random random = new Random(); while (!token.IsCancellationRequested) { try { await proxy.InvokeAsync(c => InvokeRandomAsync(random, c)); } catch (Exception) { } await Task.Delay(TimeSpan.FromMilliseconds(250.0d)); } } await factory.CloseAsync(); }
public RouterActor(bool useDefault = true) { ConnectionMode connectionMode = ConnectionMode.ConnectionModeRemoteConnectionless; IConnectionManager connectionManager = new ConnectionManager(); FalconConnection falconConnection = default(FalconConnection); if (useDefault) falconConnection = connectionManager.GetDefaultConnection(); else falconConnection = connectionManager.GetConnection("", 1); _connection = ConnectionObjectFactory.CreateUnlicensedConnectionObject(null); _auto = new AutoDisposeConnectionObject(_connection); _connection.Mode = connectionMode; if (falconConnection.guidEdi == Guid.Empty) throw new Exception("Operation was aborted"); DeviceOpenError err = _connection.Open2("{" + falconConnection.guidEdi.ToString() + "}", falconConnection.Parameters); if (err != DeviceOpenError.DeviceOpenErrorNoError) { throw new InvalidOperationException(string.Format("Could not open connection: {0}", err.ToString())); } beginConfirmedGroupDataChannel(); }
private void newConnectionRequest(ConnectionManager.ConnectionInformation connection) { ConnectionHandeler handeler = new ConnectionHandeler(connection); handeler.Disconnection += serverDisconnected; AddConnection(handeler); handeler.Start(); }
public ConnectionItem(ConnectionManager connectionManager) { ArgumentVerifier.CheckObjectArgument(connectionManager, "connectionManager"); this.name = connectionManager.Name; this.connectionManager = connectionManager; }
public WinSCPWrapper(ConnectionManager cm, object txn) { this.cm = cm; this.txn = txn; this.StartSession(); }
/// <summary> /// Create an instance of <see cref="IBatcher"/> according to the configuration /// and the capabilities of the driver /// </summary> /// <remarks> /// By default, .Net doesn't have any batching capabilities, drivers that does have /// batching support need to override this method and return their own batcher. /// </remarks> public override IBatcher CreateBatcher(ConnectionManager connectionManager) { if (connectionManager.Factory.IsBatchUpdateEnabled) return new OracleDataClientBatchingBatcher(connectionManager); else return new NonBatchingBatcher(connectionManager); }
public ContactRepository(ConnectionManager connectionManager) { connMgr = connectionManager; //Create the Contact table if it doesn't exist connMgr.Database.CreateEntityTable<Contact>(); }
internal static void SetupListener(int Port) { SessionManagement.Init(); manager = new ConnectionManager(Port, 5, new HeartbeatParser(), false); manager.connectionEvent += manager_connectionEvent; }
public void CreateFileConnection(Package p) { ConMgr = p.Connections.Add("File"); ConMgr.ConnectionString = @"\\<yourserver>\<yourfolder>\books.xml"; ConMgr.Name = "SSIS Connection Manager for Files"; ConMgr.Description = "Flat File connection"; }
public override IDTSComponentMetaData100 AddDestAdapter(IDTSPipeline100 pipeline, ConnectionManager destConnMgr, out IDTSDesigntimeComponent100 destDesignTimeComp) { if (String.IsNullOrEmpty(quotedTableName)) { throw new ArgumentException("Destination table name is empty"); } IDTSComponentMetaData100 destComp = pipeline.ComponentMetaDataCollection.New(); destComp.ComponentClassID = OLEDB_DEST_GUID; destComp.ValidateExternalMetadata = true; destDesignTimeComp = destComp.Instantiate(); destDesignTimeComp.ProvideComponentProperties(); destComp.Name = "OleDB Destination - Sql Server"; destDesignTimeComp.SetComponentProperty("AccessMode", 0); destDesignTimeComp.SetComponentProperty("OpenRowset", quotedTableName); // set connection destComp.RuntimeConnectionCollection[0].ConnectionManager = DtsConvert.GetExtendedInterface(destConnMgr); destComp.RuntimeConnectionCollection[0].ConnectionManagerID = destConnMgr.ID; // get metadata destDesignTimeComp.AcquireConnections(null); destDesignTimeComp.ReinitializeMetaData(); destDesignTimeComp.ReleaseConnections(); extCols = destComp.InputCollection[0].ExternalMetadataColumnCollection; return destComp; }
public void connect(string args) { string[] javascriptArgs = JsonHelper.Deserialize<string[]>(args); string macAddress = javascriptArgs[0]; connectionCallbackId = javascriptArgs[1]; connectionManager = new ConnectionManager(); connectionManager.Initialize(); // TODO can't we put this in the constructor? connectionManager.ByteReceived += connectionManager_ByteReceived; connectionManager.ConnectionSuccess += connectionManager_ConnectionSuccess; connectionManager.ConnectionFailure += connectionManager_ConnectionFailure; try { HostName deviceHostName = new HostName(macAddress); connectionManager.Connect(deviceHostName); } catch (Exception ex) { Debug.WriteLine(ex); connectionManager_ConnectionFailure("Invalid Hostname"); } }
/// <summary> /// Constructor. Inicializa instancias de la clase ConnectionManagerTester /// </summary> public ConnectionManagerTester() { /* * Primero se crea el CommandManager. Este gestiona los comandos de * sistema como alive, busy, ready, etc. Ahorra trabajo. * Adicionalmente se suscriben los eventos (apuntador a funcion) * para manejar las notificaciones de la clase */ commandManager = new CommandManager(); commandManager.Started += new CommandManagerStatusChangedEventHandler(commandManager_Started); commandManager.Stopped += new CommandManagerStatusChangedEventHandler(commandManager_Stopped); commandManager.CommandReceived += new CommandReceivedEventHandler(commandManager_CommandReceived); commandManager.ResponseReceived += new ResponseReceivedEventHandler(commandManager_ResponseReceived); /* * Ahora se inicializa el ConnectionManager. Bajo el esquema actual * todas las aplicaciones son servidores y es el blackboard el que * se conecta a ellas (asi solo es necesario configurar una * aplicacion). Se le indica nombre del modulo, puerto de conexion * y el gestor de comandos. El modulo y puerto deben ser * configurados en el blackboard */ connectionManager = new ConnectionManager("TESTER", 2000, 2000, IPAddress.Loopback, commandManager); connectionManager.Started += new ConnectionManagerStatusChangedEventHandler(connectionManager_Started); connectionManager.Stopped += new ConnectionManagerStatusChangedEventHandler(connectionManager_Stopped); connectionManager.ClientDisconnected += new TcpClientDisconnectedEventHandler(connectionManager_ClientDisconnected); connectionManager.ClientConnected += new TcpClientConnectedEventHandler(connectionManager_ClientConnected); // Configuro el reloj sw = new System.Diagnostics.Stopwatch(); }
public AppManager(ConnectionManager connectionManager, IDeviceInfo deviceInfo, AccountManager accountManager) : base(connectionManager) { _deviceInfo = deviceInfo; _accountManager = accountManager; }
public ConnectionRun(RunData runData) : base(runData) { var connectionManager = new ConnectionManager(Resolver); _context = connectionManager.GetConnectionContext<StressConnection>(); _transportConnection = (ITransportConnection)_context.Connection; }
void IDtsConnectionManagerUI.Initialize(ConnectionManager connectionManager, IServiceProvider serviceProvider) { Debug.Assert((connectionManager != null) && (serviceProvider != null)); this._serviceProvider = serviceProvider; this._connectionManager = connectionManager; }
public SQLServerWrapper(ConnectionManager cm, object txn) { this.cm = cm; this.txn = txn; this.StartSession(); }
// Setup function public void Setup() { _transport = new SerialTransport {CurrentSerialSettings = {DtrEnable = false}}; // some boards (e.g. Sparkfun Pro Micro) DtrEnable may need to be true. // We do not need to set serial port and baud rate: it will be found by the connection manager // Initialize the command messenger with the Serial Port transport layer // Set if it is communicating with a 16- or 32-bit Arduino board _cmdMessenger = new CmdMessenger(_transport, BoardType.Bit16) { PrintLfCr = false // Do not print newLine at end of command, to reduce data being sent }; // The Connection manager is capable or storing connection settings, in order to reconnect more quickly // the next time the application is run. You can determine yourself where and how to store the settings // by supplying a class, that implements ISerialConnectionStorer. For convenience, CmdMessenger provides // simple binary file storage functionality var serialConnectionStorer = new SerialConnectionStorer("SerialConnectionManagerSettings.cfg"); // We don't need to provide a handler for the Identify command - this is a job for Connection Manager. _connectionManager = new SerialConnectionManager( _transport as SerialTransport, _cmdMessenger, (int) Command.Identify, CommunicationIdentifier, serialConnectionStorer) { // Enable watchdog functionality. WatchdogEnabled = true, // Instead of scanning for the connected port, you can disable scanning and only try the port set in CurrentSerialSettings //DeviceScanEnabled = false }; // Show all connection progress on command line _connectionManager.Progress += (sender, eventArgs) => { // If you want to reduce verbosity, you can only show events of level <=2 or ==1 if (eventArgs.Level <= 3) Console.WriteLine(eventArgs.Description); }; // If connection found, tell the arduino to turn the (internal) led on _connectionManager.ConnectionFound += (sender, eventArgs) => { // Create command var command = new SendCommand((int)Command.TurnLedOn); // Send command _cmdMessenger.SendCommand(command); }; //You can also do something when the connection is lost _connectionManager.ConnectionTimeout += (sender, eventArgs) => { //Do something }; // Finally - activate connection manager _connectionManager.StartConnectionManager(); }
public ConnectionHandeling(int port, int maxConnections, int connectionsPerIP, bool enabeNagles) { this.liveConnections = new Hashtable(maxConnections); this.manager = new ConnectionManager(port, maxConnections, new InitialPacketParser(), !enabeNagles); //this.manager = new SocketManager(); //int portID, int maxConnections, int connectionsPerIP, IDataParser parser, bool disableNaglesAlgorithm) //this.manager.init(port, maxConnections, connectionsPerIP, new InitialPacketParser(), !enabeNagles); }
public GroupsManager(MessagesManager messagesManager, ConnectionManager connectionManager, GroupChatsService groupChatsService) { this.messagesManager = messagesManager; this.connectionManager = connectionManager; this.groupChatsService = groupChatsService; groupChatsService.GroupChanged += OnGroupChanged; }
public void ShouldLeaveOpenConnectionOpen() { DbConnection connection = Substitute.For<DbConnection>(); connection.State.Returns(ConnectionState.Open); ConnectionManager manager = new ConnectionManager(connection); manager.Dispose(); connection.Received(0).Close(); }
public RabbitMQConnectionManagerUIForm(Microsoft.SqlServer.Dts.Runtime.ConnectionManager connectionManager, IServiceProvider serviceProvider) : this() { this.connectionManager = connectionManager; this.serviceProvider = serviceProvider; SetFormValuesFromConnectionManager(); }
internal BuildManager(GlobalManager globalManager) { _globalManager = globalManager; _connectionManager = new ConnectionManager(globalManager); _colorManager = new ColorManager(globalManager); _sizeManager = new SizeManager(globalManager); _jsonTreeManager = new JsonTreeManager(globalManager); }
public EzConnectionManager(EzPackage parent) { if (parent == null) throw new ArgumentNullException("parent"); m_parent = parent; m_conn = parent.Connections.Add(GetConnMgrID()); Name = GetType().Name + ID; }
private void appStartup(object sender, StartupEventArgs e) { // create connection manager connectionManager = new ConnectionManager(); // create main window and display it mainWindow = new MainWindow(); mainWindow.Show(); }
public ChatManager(ConnectionManager connectionManager, ChatServiceProxy chatServiceProxy, AccountManager accountManager) : base(connectionManager) { _chatServiceProxy = chatServiceProxy; _accountManager = accountManager; Messages = new ObservableCollection<Event>(); OnlineUsers = new ObservableCollection<UserDto>(); }
public void ShouldOpenAndCloseClosedConnection() { DbConnection connection = Substitute.For<DbConnection>(); connection.State.Returns(ConnectionState.Closed); ConnectionManager manager = new ConnectionManager(connection); manager.Dispose(); connection.Received(1).Open(); connection.Received(1).Close(); }
// Class definition for OLE DB Provider. public void CreateOLEDBConnection(Package p) { ConMgr = p.Connections.Add("OLEDB"); ConMgr.ConnectionString = "Provider=SQLOLEDB.1;" + "Integrated Security=SSPI;Initial Catalog=AdventureWorks;" + "Data Source=(local);"; ConMgr.Name = "SSIS Connection Manager for OLE DB"; ConMgr.Description = "OLE DB connection to the AdventureWorks database."; }
public MainWindow() { InitializeComponent(); // uloz si odkaz na connection manager z aplikace OracleAdmin app = Application.Current as OracleAdmin; connectionMgr = app.ConnectionManager; masterView.ItemsSource = new CompositeCollection(2) { connectionMgr }; }
public ClienteService(string connectionString) { conexion = new ConnectionManager(connectionString); repositorio = new ClienteRepository(conexion); }
public object Get(GetConnnectionManager request) { var xml = ConnectionManager.GetServiceXml(Request.Headers.ToDictionary()); return(_resultFactory.GetResult(Request, xml, XMLContentType)); }
private void AddFavorite(IPEndPoint endPoint) { try { string serverName = endPoint.Address.ToString(); string connectionName = serverName; FavoriteConfigurationElement newFavorite = FavoritesFactory.CreateNewFavorite(connectionName, serverName, typeof(RDPConnection) .GetProtocolName(), ConnectionManager.GetPort( typeof(RDPConnection) .GetProtocolName())); this.AddFavoriteToDiscovered(newFavorite); } catch (Exception e) { Log.Error("Add Favorite Error", e); } }
private static SqlDataAdapter InicializarAdaptador() { String getSQL = "dbo.invGetLote"; String InsertSQL = "[dbo].[invUpdateLote]"; String UpdateSQL = "[dbo].[invUpdateLote]"; String DeleteSQL = "[dbo].[invUpdateLote]"; try { SqlDataAdapter oAdaptador = new SqlDataAdapter() { SelectCommand = new SqlCommand(getSQL, ConnectionManager.GetConnection()), InsertCommand = new SqlCommand(InsertSQL, ConnectionManager.GetConnection()), UpdateCommand = new SqlCommand(UpdateSQL, ConnectionManager.GetConnection()), DeleteCommand = new SqlCommand(DeleteSQL, ConnectionManager.GetConnection()) }; //Paremetros Select oAdaptador.SelectCommand.CommandType = CommandType.StoredProcedure; oAdaptador.SelectCommand.Parameters.Add("@IDLote", SqlDbType.Int).SourceColumn = "IDLote"; oAdaptador.SelectCommand.Parameters.Add("@IDProducto", SqlDbType.Int).SourceColumn = "IDProducto"; oAdaptador.SelectCommand.Parameters.Add("@LoteInterno", SqlDbType.NVarChar).SourceColumn = "LoteInterno"; oAdaptador.SelectCommand.Parameters.Add("@LoteProveedor", SqlDbType.NVarChar).SourceColumn = "LoteProveedor"; //Paremetros Insert oAdaptador.InsertCommand.CommandType = CommandType.StoredProcedure; oAdaptador.InsertCommand.Parameters.Add("@Operacion", SqlDbType.NChar).Value = "I"; oAdaptador.InsertCommand.Parameters.Add("@IDLote", SqlDbType.Int).SourceColumn = "IDLote"; oAdaptador.InsertCommand.Parameters.Add("@IDProducto", SqlDbType.Int).SourceColumn = "IDProducto"; oAdaptador.InsertCommand.Parameters.Add("@LoteInterno", SqlDbType.NVarChar).SourceColumn = "LoteInterno"; oAdaptador.InsertCommand.Parameters.Add("@LoteProveedor", SqlDbType.NVarChar).SourceColumn = "LoteProveedor"; oAdaptador.InsertCommand.Parameters.Add("@FechaVencimiento", SqlDbType.Date).SourceColumn = "FechaVencimiento"; oAdaptador.InsertCommand.Parameters.Add("@FechaFabricacion", SqlDbType.Date).SourceColumn = "FechaFabricacion"; oAdaptador.InsertCommand.Parameters.Add("@FechaIngreso", SqlDbType.DateTime).SourceColumn = "FechaIngreso"; //Paremetros Update oAdaptador.UpdateCommand.CommandType = CommandType.StoredProcedure; oAdaptador.UpdateCommand.Parameters.Add("@Operacion", SqlDbType.NChar).Value = "U"; oAdaptador.UpdateCommand.Parameters.Add("@IDLote", SqlDbType.Int).SourceColumn = "IDLote"; oAdaptador.UpdateCommand.Parameters.Add("@IDProducto", SqlDbType.Int).SourceColumn = "IDProducto"; oAdaptador.UpdateCommand.Parameters.Add("@LoteInterno", SqlDbType.NVarChar).SourceColumn = "LoteInterno"; oAdaptador.UpdateCommand.Parameters.Add("@LoteProveedor", SqlDbType.NVarChar).SourceColumn = "LoteProveedor"; oAdaptador.UpdateCommand.Parameters.Add("@FechaVencimiento", SqlDbType.Date).SourceColumn = "FechaVencimiento"; oAdaptador.UpdateCommand.Parameters.Add("@FechaFabricacion", SqlDbType.Date).SourceColumn = "FechaFabricacion"; oAdaptador.UpdateCommand.Parameters.Add("@FechaIngreso", SqlDbType.DateTime).SourceColumn = "FechaIngreso"; //Paremetros Delete oAdaptador.DeleteCommand.CommandType = CommandType.StoredProcedure; oAdaptador.DeleteCommand.Parameters.Add("@Operacion", SqlDbType.NChar).Value = "D"; oAdaptador.DeleteCommand.Parameters.Add("@IDLote", SqlDbType.Int).SourceColumn = "IDLote"; oAdaptador.DeleteCommand.Parameters.Add("@IDProducto", SqlDbType.Int).SourceColumn = "IDProducto"; oAdaptador.DeleteCommand.Parameters.Add("@LoteInterno", SqlDbType.NVarChar).SourceColumn = "LoteInterno"; oAdaptador.DeleteCommand.Parameters.Add("@LoteProveedor", SqlDbType.NVarChar).SourceColumn = "LoteProveedor"; oAdaptador.DeleteCommand.Parameters.Add("@FechaVencimiento", SqlDbType.Date).SourceColumn = "FechaVencimiento"; oAdaptador.DeleteCommand.Parameters.Add("@FechaFabricacion", SqlDbType.Date).SourceColumn = "FechaFabricacion"; oAdaptador.DeleteCommand.Parameters.Add("@FechaIngreso", SqlDbType.DateTime).SourceColumn = "FechaIngreso"; return(oAdaptador); } catch (Exception) { throw; } }
public static void ClearDatabase(int databaseIndex) { ConnectionManager.GetServer().FlushDatabase(databaseIndex); }
public SocketHandeler(ConnectionManager connection) { Connection = connection; }
public static async Task MyClassInitialize(TestContext testContext) { // Test script executor (create database) await ScriptExecutor.ExecuteScriptAsync(ConnectionManager.GetConnection("Master"), @" USE master GO IF EXISTS ( SELECT NAME FROM Sys.Databases WHERE Name = N'UpdateConcurrencyAsyncTest' ) BEGIN DROP DATABASE UpdateConcurrencyAsyncTest END GO CREATE DATABASE UpdateConcurrencyAsyncTest GO USE UpdateConcurrencyAsyncTest GO CREATE TABLE UpdateConcurrencyAsyncTest..Message( [MessageId] INT NOT NULL, [Text] VARCHAR(50), [RowVersion] ROWVERSION ) GO ALTER TABLE UpdateConcurrencyAsyncTest..Message ADD CONSTRAINT Message_PK PRIMARY KEY (MessageId) GO ", "^GO"); await ScriptExecutor.ExecuteScriptAsync(ConnectionManager.GetConnection(connectionName), @"CREATE PROCEDURE [p_Message_Get] @messageId INT AS BEGIN SET NOCOUNT ON; SELECT [MessageId], [Text], [RowVersion] FROM [Message] WHERE [MessageId] = @messageId END; GO CREATE PROCEDURE [dbo].[p_Message_Update] @messageId INT, @text VARCHAR(50), @rowVersion ROWVERSION OUTPUT AS BEGIN --SET NOCOUNT ON; If this is ON then ExecuteNonQuery returns -1! DECLARE @messageOutputData TABLE ( [RowVersion] BINARY(8) ); UPDATE UpdateConcurrencyAsyncTest..Message SET [Text] = @text OUTPUT INSERTED.[RowVersion] INTO @messageOutputData WHERE [MessageId] = @messageId AND [RowVersion] = @rowVersion; --IF @@ROWCOUNT != 1 BEGIN --RAISERROR('Row versions do not match.', 16, 1); --END SET @rowVersion = (SELECT [RowVersion] FROM @messageOutputData); END; GO -- Insert message to modify during the test INSERT INTO UpdateConcurrencyAsyncTest..Message ( [MessageId], [Text] ) VALUES ( 1, 'Message to modify' ); ", "^GO"); }
public PersonaService(string connectionString) { _repositorio = new PersonaRepository(_conexion); _conexion = new ConnectionManager(connectionString); }
protected override void Load(ContainerBuilder builder) { // IMessageConverter<IRoutingMessage> builder.Register(c => new RoutingMessageConverter()) .As <Core.IMessageConverter <IRoutingMessage> >() .SingleInstance(); // IRoutingPerfCounter builder.Register( c => { Routing.PerfCounter = NullRoutingPerfCounter.Instance; return(Routing.PerfCounter); }) .As <IRoutingPerfCounter>() .AutoActivate() .SingleInstance(); // IRoutingUserAnalyticsLogger builder.Register( c => { Routing.UserAnalyticsLogger = NullUserAnalyticsLogger.Instance; return(Routing.UserAnalyticsLogger); }) .As <IRoutingUserAnalyticsLogger>() .AutoActivate() .SingleInstance(); // IRoutingUserMetricLogger builder.Register( c => { Routing.UserMetricLogger = NullRoutingUserMetricLogger.Instance; return(Routing.UserMetricLogger); }) .As <IRoutingUserMetricLogger>() .AutoActivate() .SingleInstance(); // IMessageConverter<Message> builder.Register(c => new DeviceClientMessageConverter()) .As <Core.IMessageConverter <Message> >() .SingleInstance(); // IMessageConverter<Twin> builder.Register(c => new TwinMessageConverter()) .As <Core.IMessageConverter <Twin> >() .SingleInstance(); // IMessageConverter<TwinCollection> builder.Register(c => new TwinCollectionMessageConverter()) .As <Core.IMessageConverter <TwinCollection> >() .SingleInstance(); // IMessageConverterProvider builder.Register( c => new MessageConverterProvider( new Dictionary <Type, IMessageConverter>() { { typeof(Message), c.Resolve <Core.IMessageConverter <Message> >() }, { typeof(Twin), c.Resolve <Core.IMessageConverter <Twin> >() }, { typeof(TwinCollection), c.Resolve <Core.IMessageConverter <TwinCollection> >() } })) .As <IMessageConverterProvider>() .SingleInstance(); // IDeviceConnectivityManager builder.Register( c => { var edgeHubCredentials = c.ResolveNamed <IClientCredentials>("EdgeHubCredentials"); IDeviceConnectivityManager deviceConnectivityManager = new DeviceConnectivityManager(this.connectivityCheckFrequency, TimeSpan.FromMinutes(2), edgeHubCredentials.Identity); return(deviceConnectivityManager); }) .As <IDeviceConnectivityManager>() .SingleInstance(); // IDeviceClientProvider builder.Register( c => { IClientProvider underlyingClientProvider = new ClientProvider(); IClientProvider connectivityAwareClientProvider = new ConnectivityAwareClientProvider(underlyingClientProvider, c.Resolve <IDeviceConnectivityManager>()); return(connectivityAwareClientProvider); }) .As <IClientProvider>() .SingleInstance(); // Task<ICloudConnectionProvider> builder.Register( async c => { var productInfoStore = c.Resolve <IProductInfoStore>(); var messageConverterProvider = c.Resolve <IMessageConverterProvider>(); var clientProvider = c.Resolve <IClientProvider>(); var tokenProvider = c.ResolveNamed <ITokenProvider>("EdgeHubClientAuthTokenProvider"); var credentialsCacheTask = c.Resolve <Task <ICredentialsCache> >(); var edgeHubCredentials = c.ResolveNamed <IClientCredentials>("EdgeHubCredentials"); var deviceScopeIdentitiesCacheTask = c.Resolve <Task <IDeviceScopeIdentitiesCache> >(); var proxy = c.Resolve <Option <IWebProxy> >(); IDeviceScopeIdentitiesCache deviceScopeIdentitiesCache = await deviceScopeIdentitiesCacheTask; ICredentialsCache credentialsCache = await credentialsCacheTask; ICloudConnectionProvider cloudConnectionProvider = new CloudConnectionProvider( messageConverterProvider, this.connectionPoolSize, clientProvider, this.upstreamProtocol, tokenProvider, deviceScopeIdentitiesCache, credentialsCache, edgeHubCredentials.Identity, this.cloudConnectionIdleTimeout, this.closeCloudConnectionOnIdleTimeout, this.operationTimeout, proxy, productInfoStore); return(cloudConnectionProvider); }) .As <Task <ICloudConnectionProvider> >() .SingleInstance(); // IIdentityProvider builder.Register(_ => new IdentityProvider(this.iotHubName)) .As <IIdentityProvider>() .SingleInstance(); // Task<IConnectionManager> builder.Register( async c => { var cloudConnectionProviderTask = c.Resolve <Task <ICloudConnectionProvider> >(); var credentialsCacheTask = c.Resolve <Task <ICredentialsCache> >(); var identityProvider = c.Resolve <IIdentityProvider>(); ICloudConnectionProvider cloudConnectionProvider = await cloudConnectionProviderTask; ICredentialsCache credentialsCache = await credentialsCacheTask; IConnectionManager connectionManager = new ConnectionManager( cloudConnectionProvider, credentialsCache, identityProvider, this.maxConnectedClients); return(connectionManager); }) .As <Task <IConnectionManager> >() .SingleInstance(); // Task<IEndpointFactory> builder.Register( async c => { var messageConverter = c.Resolve <Core.IMessageConverter <IRoutingMessage> >(); IConnectionManager connectionManager = await c.Resolve <Task <IConnectionManager> >(); return(new EndpointFactory(connectionManager, messageConverter, this.edgeDeviceId, this.maxUpstreamBatchSize, this.upstreamFanOutFactor) as IEndpointFactory); }) .As <Task <IEndpointFactory> >() .SingleInstance(); // Task<RouteFactory> builder.Register(async c => new EdgeRouteFactory(await c.Resolve <Task <IEndpointFactory> >()) as RouteFactory) .As <Task <RouteFactory> >() .SingleInstance(); // RouterConfig builder.Register(c => new RouterConfig(Enumerable.Empty <Route>())) .As <RouterConfig>() .SingleInstance(); if (!this.isStoreAndForwardEnabled) { // EndpointExecutorConfig builder.Register( c => { RetryStrategy defaultRetryStrategy = new FixedInterval(0, TimeSpan.FromSeconds(1)); TimeSpan defaultRevivePeriod = TimeSpan.FromHours(1); TimeSpan defaultTimeout = TimeSpan.FromSeconds(60); return(new EndpointExecutorConfig(defaultTimeout, defaultRetryStrategy, defaultRevivePeriod, true)); }) .As <EndpointExecutorConfig>() .SingleInstance(); // IEndpointExecutorFactory builder.Register(c => new SyncEndpointExecutorFactory(c.Resolve <EndpointExecutorConfig>())) .As <IEndpointExecutorFactory>() .SingleInstance(); // Task<Router> builder.Register( async c => { var endpointExecutorFactory = c.Resolve <IEndpointExecutorFactory>(); var routerConfig = c.Resolve <RouterConfig>(); Router router = await Router.CreateAsync(Guid.NewGuid().ToString(), this.iotHubName, routerConfig, endpointExecutorFactory); return(router); }) .As <Task <Router> >() .SingleInstance(); // Task<ITwinManager> builder.Register( async c => { if (this.useV1TwinManager) { var messageConverterProvider = c.Resolve <IMessageConverterProvider>(); IConnectionManager connectionManager = await c.Resolve <Task <IConnectionManager> >(); ITwinManager twinManager = new PassThroughTwinManager(connectionManager, messageConverterProvider); return(twinManager); } else { var messageConverterProvider = c.Resolve <IMessageConverterProvider>(); IConnectionManager connectionManager = await c.Resolve <Task <IConnectionManager> >(); return(TwinManager.CreateTwinManager(connectionManager, messageConverterProvider, Option.None <IStoreProvider>())); } }) .As <Task <ITwinManager> >() .SingleInstance(); } else { // EndpointExecutorConfig builder.Register( c => { // Endpoint executor config values - // ExponentialBackoff - minBackoff = 1s, maxBackoff = 60s, delta (used to add randomness to backoff) - 1s (default) // Num of retries = int.MaxValue(we want to keep retrying till the message is sent) // Revive period - period for which the endpoint should be considered dead if it doesn't respond - 1 min (we want to try continuously till the message expires) // Timeout - time for which we want for the ack from the endpoint = 30s // TODO - Should the number of retries be tied to the Store and Forward ttl? Not // doing that right now as that value can be changed at runtime, but these settings // cannot. Need to make the number of retries dynamically configurable for that. TimeSpan minWait = TimeSpan.FromSeconds(1); TimeSpan maxWait = TimeSpan.FromSeconds(60); TimeSpan delta = TimeSpan.FromSeconds(1); int retries = int.MaxValue; RetryStrategy retryStrategy = new ExponentialBackoff(retries, minWait, maxWait, delta); TimeSpan timeout = TimeSpan.FromSeconds(30); TimeSpan revivePeriod = TimeSpan.FromSeconds(30); return(new EndpointExecutorConfig(timeout, retryStrategy, revivePeriod)); }) .As <EndpointExecutorConfig>() .SingleInstance(); // ICheckpointStore builder.Register( c => { var dbStoreProvider = c.Resolve <IDbStoreProvider>(); IStoreProvider storeProvider = new StoreProvider(dbStoreProvider); return(CheckpointStore.Create(storeProvider)); }) .As <ICheckpointStore>() .SingleInstance(); // IMessageStore builder.Register( c => { var checkpointStore = c.Resolve <ICheckpointStore>(); var dbStoreProvider = c.Resolve <IDbStoreProvider>(); IStoreProvider storeProvider = new StoreProvider(dbStoreProvider); IMessageStore messageStore = new MessageStore(storeProvider, checkpointStore, TimeSpan.MaxValue); return(messageStore); }) .As <IMessageStore>() .SingleInstance(); // IEndpointExecutorFactory builder.Register( c => { var endpointExecutorConfig = c.Resolve <EndpointExecutorConfig>(); var messageStore = c.Resolve <IMessageStore>(); IEndpointExecutorFactory endpointExecutorFactory = new StoringAsyncEndpointExecutorFactory(endpointExecutorConfig, new AsyncEndpointExecutorOptions(10, TimeSpan.FromSeconds(10)), messageStore); return(endpointExecutorFactory); }) .As <IEndpointExecutorFactory>() .SingleInstance(); // Task<Router> builder.Register( async c => { var checkpointStore = c.Resolve <ICheckpointStore>(); var routerConfig = c.Resolve <RouterConfig>(); var endpointExecutorFactory = c.Resolve <IEndpointExecutorFactory>(); return(await Router.CreateAsync(Guid.NewGuid().ToString(), this.iotHubName, routerConfig, endpointExecutorFactory, checkpointStore)); }) .As <Task <Router> >() .SingleInstance(); // Task<ITwinManager> builder.Register( async c => { if (this.useV1TwinManager) { var dbStoreProvider = c.Resolve <IDbStoreProvider>(); var messageConverterProvider = c.Resolve <IMessageConverterProvider>(); IConnectionManager connectionManager = await c.Resolve <Task <IConnectionManager> >(); return(TwinManager.CreateTwinManager(connectionManager, messageConverterProvider, Option.Some <IStoreProvider>(new StoreProvider(dbStoreProvider)))); } else { var messageConverterProvider = c.Resolve <IMessageConverterProvider>(); var deviceConnectivityManager = c.Resolve <IDeviceConnectivityManager>(); var connectionManagerTask = c.Resolve <Task <IConnectionManager> >(); IEntityStore <string, TwinStoreEntity> entityStore = await this.GetTwinStore(c); IConnectionManager connectionManager = await connectionManagerTask; ITwinManager twinManager = StoringTwinManager.Create( connectionManager, messageConverterProvider, entityStore, deviceConnectivityManager, new ReportedPropertiesValidator(), this.minTwinSyncPeriod, this.reportedPropertiesSyncFrequency); return(twinManager); } }) .As <Task <ITwinManager> >() .SingleInstance(); } // IClientCredentials "EdgeHubCredentials" builder.Register( c => { var identityFactory = c.Resolve <IClientCredentialsFactory>(); IClientCredentials edgeHubCredentials = this.connectionString.Map(cs => identityFactory.GetWithConnectionString(cs)).GetOrElse( () => identityFactory.GetWithIotEdged(this.edgeDeviceId, this.edgeModuleId)); return(edgeHubCredentials); }) .Named <IClientCredentials>("EdgeHubCredentials") .SingleInstance(); // Task<IInvokeMethodHandler> builder.Register( async c => { IConnectionManager connectionManager = await c.Resolve <Task <IConnectionManager> >(); return(new InvokeMethodHandler(connectionManager) as IInvokeMethodHandler); }) .As <Task <IInvokeMethodHandler> >() .SingleInstance(); // Task<ISubscriptionProcessor> builder.Register( async c => { var connectionManagerTask = c.Resolve <Task <IConnectionManager> >(); if (this.disableCloudSubscriptions) { return(new LocalSubscriptionProcessor(await connectionManagerTask) as ISubscriptionProcessor); } else { var invokeMethodHandlerTask = c.Resolve <Task <IInvokeMethodHandler> >(); var deviceConnectivityManager = c.Resolve <IDeviceConnectivityManager>(); IConnectionManager connectionManager = await connectionManagerTask; IInvokeMethodHandler invokeMethodHandler = await invokeMethodHandlerTask; return(new SubscriptionProcessor(connectionManager, invokeMethodHandler, deviceConnectivityManager) as ISubscriptionProcessor); } }) .As <Task <ISubscriptionProcessor> >() .SingleInstance(); // Task<IEdgeHub> builder.Register( async c => { var routingMessageConverter = c.Resolve <Core.IMessageConverter <IRoutingMessage> >(); var routerTask = c.Resolve <Task <Router> >(); var twinManagerTask = c.Resolve <Task <ITwinManager> >(); var invokeMethodHandlerTask = c.Resolve <Task <IInvokeMethodHandler> >(); var connectionManagerTask = c.Resolve <Task <IConnectionManager> >(); var subscriptionProcessorTask = c.Resolve <Task <ISubscriptionProcessor> >(); Router router = await routerTask; ITwinManager twinManager = await twinManagerTask; IConnectionManager connectionManager = await connectionManagerTask; IInvokeMethodHandler invokeMethodHandler = await invokeMethodHandlerTask; ISubscriptionProcessor subscriptionProcessor = await subscriptionProcessorTask; IEdgeHub hub = new RoutingEdgeHub( router, routingMessageConverter, connectionManager, twinManager, this.edgeDeviceId, invokeMethodHandler, subscriptionProcessor); return(hub); }) .As <Task <IEdgeHub> >() .SingleInstance(); // Task<ConfigUpdater> builder.Register( async c => { IMessageStore messageStore = this.isStoreAndForwardEnabled ? c.Resolve <IMessageStore>() : null; Router router = await c.Resolve <Task <Router> >(); var configUpdater = new ConfigUpdater(router, messageStore, this.configUpdateFrequency); return(configUpdater); }) .As <Task <ConfigUpdater> >() .SingleInstance(); // Task<IConfigSource> builder.Register( async c => { RouteFactory routeFactory = await c.Resolve <Task <RouteFactory> >(); if (this.useTwinConfig) { var edgeHubCredentials = c.ResolveNamed <IClientCredentials>("EdgeHubCredentials"); var twinCollectionMessageConverter = c.Resolve <Core.IMessageConverter <TwinCollection> >(); var twinMessageConverter = c.Resolve <Core.IMessageConverter <Twin> >(); var twinManagerTask = c.Resolve <Task <ITwinManager> >(); var edgeHubTask = c.Resolve <Task <IEdgeHub> >(); ITwinManager twinManager = await twinManagerTask; IEdgeHub edgeHub = await edgeHubTask; IConnectionManager connectionManager = await c.Resolve <Task <IConnectionManager> >(); IDeviceScopeIdentitiesCache deviceScopeIdentitiesCache = await c.Resolve <Task <IDeviceScopeIdentitiesCache> >(); IConfigSource edgeHubConnection = await EdgeHubConnection.Create( edgeHubCredentials.Identity, edgeHub, twinManager, connectionManager, routeFactory, twinCollectionMessageConverter, twinMessageConverter, this.versionInfo, deviceScopeIdentitiesCache); return(edgeHubConnection); } else { return(new LocalConfigSource(routeFactory, this.routes, this.storeAndForwardConfiguration)); } }) .As <Task <IConfigSource> >() .SingleInstance(); // Task<IConnectionProvider> builder.Register( async c => { var connectionManagerTask = c.Resolve <Task <IConnectionManager> >(); var edgeHubTask = c.Resolve <Task <IEdgeHub> >(); IConnectionManager connectionManager = await connectionManagerTask; IEdgeHub edgeHub = await edgeHubTask; IConnectionProvider connectionProvider = new ConnectionProvider(connectionManager, edgeHub); return(connectionProvider); }) .As <Task <IConnectionProvider> >() .SingleInstance(); base.Load(builder); }
public void createNewConnectionWithInvalidURL() { ConnectionManager connMgr = ConnectionManager.Instance; HttpWebRequest httpRequest = connMgr.getConnection("Not a url"); }
public async Task <bool> DeleteWhereAsync(Expression <Func <TModel, bool> > where, QueryExecutionOptions options = null) { var(whereClauseSql, whereClauseParameters) = WhereClauseCompiler.ToSql(where, language: WhereClauseCompiler.Language.MYSQL); var parameters = new DynamicParameters(whereClauseParameters); using (var unitOfWork = ConnectionManager.Connect()) { var rowsDeleted = await unitOfWork.Connection.ExecuteAsync($"DELETE FROM {TableName} WHERE {whereClauseSql}", parameters, ConnectionManager.GetCurrentTransaction(), options?.TimeoutInSeconds); return(rowsDeleted >= 0); } }
public static void UpdateDatabase(string sourceUri, ConnectionManager manager) { WebClient webClient = new WebClient(); string[] data = webClient.DownloadString(new Uri(sourceUri)).Split('\n'); for (int i = 0; i < data.Length; i++) { data[i] = data[i].Split('\r')[0]; } for (int i = 0; i < data.Length / 10; i++) { if (data[i].Equals("\t<item>")) { Article article = new Article(); article.Title = data[i + 1].Split('\t')[2]; article.Title = article.Title.Substring(7, article.Title.Length - 15); if (manager.ConfirmArticlePresence(article.Title)) { return; } article.Link = data[i + 2].Split('\t')[2]; article.Link = article.Link.Substring(6, article.Link.Length - 13); try { article.Description = data[i + 3].Split('&')[2]; article.Description = article.Description.Substring(5, article.Description.Length - 5); if (article.Description.Split(';')[0].Equals("quot")) { article.Description = data[i + 3].Split('&')[4]; article.Description = article.Description.Substring(5, article.Description.Length - 5); } } catch { article.Description = data[i + 3].Split('>')[1].Split('<')[0]; article.ImageUri = "None"; } if (article.ImageUri != "None") { string imageSource = data[i + 3].Split('"')[1]; article.ImageUri = imageSource; } string[] date = data[i + 10].Split('>'); int offset = 0; while (!date[0].Equals("\t\t<pubDate")) { date = data[i + 11 + offset].Split('>'); offset++; } date = date[1].Split('<'); article.Date = DateTime.Parse(date[0]); manager.AddArticle(article); i += 9; } } }
public MarcaService(string connectionString) { conexion = new ConnectionManager(connectionString); repositorio = new MarcaRepository(conexion); }
public MetadataMode(TorrentManager manager, DiskManager diskManager, ConnectionManager connectionManager, EngineSettings settings, string savePath, bool stopWhenDone) : base(manager, diskManager, connectionManager, settings) { this.savePath = savePath; this.stopWhenDone = stopWhenDone; }
public WebSocketMessageHandler(ConnectionManager connections) : base(connections) { }
public async Task InvokeMethodLateSubscriptionTest() { // Create a mock endpoint capable of returning a mock processor var processor = Mock.Of<IProcessor>(); var endpoint = new Mock<Endpoint>("myId"); endpoint.Setup(ep => ep.CreateProcessor()).Returns(processor); endpoint.SetupGet(ep => ep.Id).Returns("myId"); // Create a mock endpoint executor factory to create the endpoint executor to verify invocation var endpointExecutor = Mock.Of<IEndpointExecutor>(); Mock.Get(endpointExecutor).SetupGet(ee => ee.Endpoint).Returns(() => endpoint.Object); var endpointExecutorFactory = Mock.Of<IEndpointExecutorFactory>(); Mock.Get(endpointExecutorFactory).Setup(eef => eef.CreateAsync(It.IsAny<Endpoint>())).ReturnsAsync(endpointExecutor); // Create a route to map to the message var endpoints = new HashSet<Endpoint> { endpoint.Object }; var route = new Route("myRoute", "true", "myIotHub", TelemetryMessageSource.Instance, endpoints); // Create a router var routerConfig = new RouterConfig(new[] { route }); Router router = await Router.CreateAsync("myRouter", "myIotHub", routerConfig, endpointExecutorFactory); // Create mock message converter to generate a message with source matching the route var messageConverter = Mock.Of<Core.IMessageConverter<Devices.Routing.Core.IMessage>>(); var methodRequest = new DirectMethodRequest("device1/module1", "shutdown", null, TimeSpan.FromSeconds(2), TimeSpan.FromSeconds(20)); // Mock of twin manager var twinManager = Mock.Of<ITwinManager>(); // DeviceListener var identity = Mock.Of<IModuleIdentity>(m => m.DeviceId == "device1" && m.ModuleId == "module1" && m.Id == "device1/module1"); var cloudProxy = new Mock<ICloudProxy>(); // ICloudConnectionProvider var cloudConnection = Mock.Of<ICloudConnection>(c => c.IsActive && c.CloudProxy == Option.Some(cloudProxy.Object)); var cloudConnectionProvider = new Mock<ICloudConnectionProvider>(); cloudConnectionProvider.Setup(c => c.Connect(It.IsAny<IIdentity>(), It.IsAny<Action<string, CloudConnectionStatus>>())) .ReturnsAsync(Try.Success(cloudConnection)); var connectionManager = new ConnectionManager(cloudConnectionProvider.Object, Mock.Of<ICredentialsCache>(), new IdentityProvider("myIotHub")); IInvokeMethodHandler invokeMethodHandler = new InvokeMethodHandler(connectionManager); var subscriptionProcessor = new SubscriptionProcessor(connectionManager, invokeMethodHandler, Mock.Of<IDeviceConnectivityManager>()); // RoutingEdgeHub var routingEdgeHub = new RoutingEdgeHub( router, messageConverter, connectionManager, twinManager, "testEdgeDevice", invokeMethodHandler, subscriptionProcessor); var deviceMessageHandler = new DeviceMessageHandler(identity, routingEdgeHub, connectionManager); var underlyingDeviceProxy = new Mock<IDeviceProxy>(); // Arrange Message message = new EdgeMessage.Builder(new byte[0]).Build(); message.Properties[SystemProperties.CorrelationId] = methodRequest.CorrelationId; message.Properties[SystemProperties.StatusCode] = "200"; underlyingDeviceProxy.Setup(d => d.InvokeMethodAsync(It.IsAny<DirectMethodRequest>())) .Callback(() => deviceMessageHandler.ProcessMethodResponseAsync(message)) .ReturnsAsync(default(DirectMethodResponse)); underlyingDeviceProxy.SetupGet(d => d.IsActive).Returns(true); // Act deviceMessageHandler.BindDeviceProxy(underlyingDeviceProxy.Object); Task<DirectMethodResponse> responseTask = routingEdgeHub.InvokeMethodAsync(identity.Id, methodRequest); // Assert Assert.False(responseTask.IsCompleted); // Act await routingEdgeHub.AddSubscription(identity.Id, DeviceSubscription.Methods); await Task.Delay(TimeSpan.FromSeconds(5)); // Assert Assert.True(responseTask.IsCompleted); Assert.Equal(methodRequest.CorrelationId, responseTask.Result.CorrelationId); Assert.Equal(200, responseTask.Result.Status); Assert.False(responseTask.Result.Exception.HasValue); Assert.Equal(HttpStatusCode.OK, responseTask.Result.HttpStatusCode); }
private void Awake() { connectionManager = GameObject.FindGameObjectWithTag("ConnectionManager").GetComponent <ConnectionManager>(); }
public HDFSConnectionManagerUIForm(ConnectionManager connectionManager, IServiceProvider serviceProvider) : this() { this.connectionManager = connectionManager; this.serviceProvider = serviceProvider; }
public PulsacionesServicesDB(string connectionString) { conexion = new ConnectionManager(connectionString); pulsacionesRepositoryDB = new PulsacionesRepositoryDB(conexion); }
private async Task loadServicesAsync() { ServiceTypes serviceType; foreach (Service service in deviceDescription.Device.Services) { switch (service.ServiceType) { case ServiceTypesString.AVTRANSPORT: AVTransport = await XmlExtension.DeserializeUriAsync <AVTransport>(new Uri(HtmlExtension.CompleteHttpString(ipAddress, port, service.SCPDURL))); AVTransport.SetParent(); serviceType = ServiceTypes.AVTRANSPORT; break; case ServiceTypesString.CONNECTIONMANAGER: ConnectionManager = await XmlExtension.DeserializeUriAsync <ConnectionManager>(new Uri(HtmlExtension.CompleteHttpString(ipAddress, port, service.SCPDURL))); ConnectionManager.SetParent(); serviceType = ServiceTypes.CONNECTIONMANAGER; break; case ServiceTypesString.CONTENTDIRECTORY: ContentDirectory = await XmlExtension.DeserializeUriAsync <ContentDirectory>(new Uri(HtmlExtension.CompleteHttpString(ipAddress, port, service.SCPDURL))); ContentDirectory.SetParent(); serviceType = ServiceTypes.CONTENTDIRECTORY; break; case ServiceTypesString.MEDIARECEIVERREGISTRAR: MediaReceiverRegistrar = await XmlExtension.DeserializeUriAsync <MediaReceiverRegistrar>(new Uri(HtmlExtension.CompleteHttpString(ipAddress, port, service.SCPDURL))); MediaReceiverRegistrar.SetParent(); serviceType = ServiceTypes.MEDIARECEIVERREGISTRAR; break; case ServiceTypesString.RENDERINGCONTROL: RenderingControl = await XmlExtension.DeserializeUriAsync <RenderingControl>(new Uri(HtmlExtension.CompleteHttpString(ipAddress, port, service.SCPDURL))); RenderingControl.SetParent(); serviceType = ServiceTypes.RENDERINGCONTROL; break; default: serviceType = ServiceTypes.NEUTRAL; break; } if (serviceType != ServiceTypes.NEUTRAL) { serviceSCPDs.Add(new NetWorkSubscriberPayload { MediaDevice = this, URI = HtmlExtension.CompleteHttpString(ipAddress, port, service.SCPDURL), ServiceType = serviceType, }); serviceControls.Add(new NetWorkSubscriberPayload { MediaDevice = this, URI = HtmlExtension.CompleteHttpString(ipAddress, port, service.ControlURL), ServiceType = serviceType, }); serviceEvents.Add(new NetWorkSubscriberPayload { MediaDevice = this, URI = HtmlExtension.CompleteHttpString(ipAddress, port, service.EventSubURL), ServiceType = serviceType, }); } } }
public SSISAdoNetSource(AdoNetSource src, MainPipe pipe, ConnectionManager cm, ILogger logger, Application app) : base(pipe, "ADO NET Source", logger, app) { _src = src; _cm = cm; }
public MetadataMode(TorrentManager manager, DiskManager diskManager, ConnectionManager connectionManager, EngineSettings settings, string savePath) : this(manager, diskManager, connectionManager, settings, savePath, false) { }
public virtual IBatcher CreateBatcher(ConnectionManager connectionManager, IInterceptor interceptor) { return(new MySqlClientBatchingBatcher(connectionManager, interceptor)); }
private void ManageConnectionControl() { cManager = ConnectionManager.Instance; cManager.RequestPassword += (sender, e) => fHelper.RequestPassword(e.ConnectionDetail); cManager.StepChanged += (sender, e) => ccsb.SetMessage(e.CurrentStep); cManager.ConnectionSucceed += (sender, e) => { var parameter = e.Parameter as ConnectionParameterInfo; if (parameter != null) { Controls.Remove(parameter.InfoPanel); parameter.InfoPanel.Dispose(); } currentConnectionDetail = e.ConnectionDetail; service = e.OrganizationService; ccsb.SetConnectionStatus(true, e.ConnectionDetail); ccsb.SetMessage(string.Empty); if (parameter != null) { var control = parameter.ConnectionParmater as UserControl; if (control != null) { var pluginModel = control.Tag as Lazy <IXrmToolBoxPlugin, IPluginMetadata>; if (pluginModel == null) { // Actual Plugin was passed, Just update the plugin's Tab. UpdateTabConnection((TabPage)control.Parent); } else { this.DisplayPluginControl(pluginModel); } } else if (parameter.ConnectionParmater.ToString() == "ApplyConnectionToTabs" && tabControl1.TabPages.Count > 1) { ApplyConnectionToTabs(); } else { var args = parameter.ConnectionParmater as RequestConnectionEventArgs; if (args != null) { var userControl = (UserControl)args.Control; args.Control.UpdateConnection(e.OrganizationService, currentConnectionDetail, args.ActionName, args.Parameter); userControl.Parent.Text = string.Format("{0} ({1})", userControl.Parent.Text.Split(' ')[0], e.ConnectionDetail.ConnectionName); } } } else if (tabControl1.TabPages.Count > 1) { ApplyConnectionToTabs(); } this.StartPluginWithConnection(); }; cManager.ConnectionFailed += (sender, e) => { this.Invoke(new Action(() => { var infoPanel = ((ConnectionParameterInfo)e.Parameter).InfoPanel; Controls.Remove(infoPanel); if (infoPanel != null) { infoPanel.Dispose(); } MessageBox.Show(this, e.FailureReason, "Error", MessageBoxButtons.OK, MessageBoxIcon.Error); currentConnectionDetail = null; service = null; ccsb.SetConnectionStatus(false, null); ccsb.SetMessage(e.FailureReason); this.StartPluginWithConnection(); })); }; fHelper = new FormHelper(this); ccsb = new CrmConnectionStatusBar(fHelper) { Dock = DockStyle.Bottom }; Controls.Add(ccsb); }
public TrackArtistRepository(ConnectionManager connectionManager) : base(connectionManager) { }
public PageStatus(MainWindow ParentWindow) { this.ParentWindow = ParentWindow; Connection = ((App)Application.Current).Connection; InitializeComponent(); }
private void MainForm_CalcBalance(object sender, EventArgs e) { ConnectionManager connectionManager = new ConnectionManager(); numericUpDownSum.Text = connectionManager.CalcBalance().ToString(); }
private async void modifyVideoButton_Click(object sender, RoutedEventArgs e) { progressRing.isActive = true; VideoUpdateRequest request = new VideoUpdateRequest() { VideoID = VideoID, Title = titleTextBlock.Text, Description = descriptionTextBlock.Text, IsThumbnailUpdateRequired = thumbnailChosen, Tags = new List <string>() }; foreach (Tags tags in ((WrapPanel)tagsContainer).Children) { request.Tags.Add(tags.TagName); } Object resp = await ConnectionManager.SendRequestAsync(request, RequestType.VideoUpdate, ResponseType.VideoUpdate); if (resp != null) { VideoUpdateResponse ack = ((JObject)resp).ToObject <VideoUpdateResponse>(); if (ack.Status == "OK") { if (thumbnailChosen) { string tempPath = "Temporary/" + Guid.NewGuid() + ".jpg"; if (Directory.Exists("Temporary/")) { Directory.CreateDirectory("Temporary/"); } File.Copy(thumbnailPath, tempPath); var result = await ConnectionManager.SendFileAsync(tempPath, null); if (result != null) { var response = ((JObject)result).ToObject <Acknowledge>(); errorTextBlock.Text = response.Reason; if (response.Status == "OK") { AppNotificationManager.PushMessage(new AppNotification() { Message = response.Reason }); Close(); } } if (File.Exists(tempPath)) { File.Delete(tempPath); } } AppNotificationManager.PushMessage(new AppNotification() { Message = ack.Reason }); Close(); } errorTextBlock.Text = ack.Reason; } else { errorTextBlock.Text = "Connection Error."; } }
private void MainForm_UpdateDiagram(object sender, EventArgs e) { ConnectionManager connectionManager = new ConnectionManager(); this.pieChart.DrawFromData(connectionManager.GetAlterations()); }
public ServiciosService(string connectionString) { conexion = new ConnectionManager(connectionString); serviciorepositorio = new ServiciosRepository(conexion); }