private void RunProfilingTypes() { ProfilingTypeSettingsCollection profilingTypesSettings = _configurationSettings.ProfilingTypesSettings; List <IProfilingTypeAdapter> adapters = new List <IProfilingTypeAdapter>(); foreach (ProfilingTypeSettings profilingTypeSettings in profilingTypesSettings) { IProfilingType profilingType = ProfilingTypes[profilingTypeSettings.Uid]; IProfilingTypeAdapter adapter = profilingType.GetWinAdapter(); adapters.Add(adapter); } foreach (IProfilingTypeAdapter adapter in adapters) { IServiceConsumer serviceConsumer = adapter as IServiceConsumer; if (serviceConsumer != null) { serviceConsumer.ExportServices(_session.ServiceContainer); } } foreach (IProfilingTypeAdapter adapter in adapters) { IServiceConsumer serviceConsumer = adapter as IServiceConsumer; if (serviceConsumer != null) { serviceConsumer.ImportServices(_session.ServiceContainer); } } }
public BotInstance(IServiceConsumer <ISteamBotCoordinator> coordinator, ILogProvider logProvider, BotCookieManager cookieManager, MqClientProvider mqClientProvider) { _coordinator = coordinator; _logger = logProvider.Logger; _mqClientProvider = mqClientProvider; CookieManager = cookieManager; _callbackManager = new CallbackManager(SteamClient); _callbackManager.Subscribe <SteamClient.ConnectedCallback>(OnConnected); _callbackManager.Subscribe <SteamClient.DisconnectedCallback>(OnDisconnected); _callbackManager.Subscribe <SteamUser.LoggedOnCallback>(OnLoggedOn); _callbackManager.Subscribe <SteamUser.UpdateMachineAuthCallback>(OnUpdateMachineAuth); _callbackManager.Subscribe <SteamUser.LoginKeyCallback>(OnLoginKeyReceived); _callbackManager.Subscribe <SteamFriends.PersonaStateCallback>(OnPersonaStateChanged); _callbackManager.Subscribe <SteamFriends.FriendsListCallback>(OnFriendListUpdated); _callbackManager.Subscribe <SteamFriends.FriendMsgCallback>(OnFriendMessageReceived); _steamUser = SteamClient.GetHandler <SteamUser>(); SteamFriends = SteamClient.GetHandler <SteamFriends>(); SteamApps = SteamClient.GetHandler <SteamApps>(); }
private void RunProductivities() { List <IProductivityAdapter> adapters = new List <IProductivityAdapter>(); foreach (IProductivity productivity in Productivities) { IProductivityAdapter adapter = productivity.GetWinAdapter(); adapters.Add(adapter); } foreach (IProductivityAdapter adapter in adapters) { IServiceConsumer serviceConsumer = adapter as IServiceConsumer; if (serviceConsumer != null) { serviceConsumer.ExportServices(_session.ServiceContainer); } } foreach (IProductivityAdapter adapter in adapters) { IServiceConsumer serviceConsumer = adapter as IServiceConsumer; if (serviceConsumer != null) { serviceConsumer.ImportServices(_session.ServiceContainer); } } }
/// <summary> /// Load a consumer object into its own app domain /// </summary> /// <param name="assemblyName"></param> /// <param name="typeName"></param> /// <param name="name"></param> private void LoadConsumer(String assemblyName, String typeName, String name) { Assembly assembly = Assembly.Load(assemblyName); Type consumerType = assembly.GetType(typeName); if (consumerType == null) { Log.Error("Consumer type could not be loaded: '" + name + "'"); return; } IServiceConsumer consumer = Activator.CreateInstance(assembly.GetType(typeName)) as IServiceConsumer; if (consumer == null) { Log.Error("Consumer instance could not be created or does not derive from IServiceConsumer: '" + name + "'"); return; } Object[] attributes = consumer.GetType().GetCustomAttributes(typeof(GuidAttribute), true); Guid consumerId = (attributes.Length == 0 ? Guid.Empty : new Guid(((GuidAttribute)attributes[0]).Value)); if (consumerId == Guid.Empty) { Log.Error("Consumer '" + typeName + "' has no Guid assigned"); return; } ServiceConsumerInfo info = new ServiceConsumerInfo(); info.Id = consumerId; info.ServiceConsumer = consumer; ServiceConsumers[consumerId] = info; }
public void Initialize() { serviceAMock = new Mock <IServiceA>(); serviceBMock = new Mock <IServiceB>(); sut = new ServiceConsumer( serviceAMock.Object, serviceBMock.Object); }
/// <summary> /// Get pre-connection information for a service /// </summary> /// <param name="appId">The id of the service</param> /// <returns>Returns connection information like the config datatype</returns> public ServiceConnectData GetConnectData(Guid appId) { // find the service consumer ServiceConsumerInfo consumerInfo; if (!ServiceConsumers.TryGetValue(appId, out consumerInfo)) { return(new ServiceConnectData()); } IServiceConsumer consumer = consumerInfo.ServiceConsumer; return(new ServiceConnectData(consumer.ConfigData)); }
/// <summary> /// Registers a Service Consumer if the service exists /// </summary> /// <param name="consumer"></param> /// <param name="consumedServiceName"></param> /// <param name="stackIfServiceDoesNotExist">if true, the consumer will be stacked and registered, as soon as the correct service registeres</param> /// <returns></returns> public bool RegisterServiceConsumer(IServiceConsumer <IServiceMessage> consumer, string consumedServiceName, bool stackIfServiceDoesNotExist = true) { //Check if service exists if (serviceNameTable.ContainsKey(consumedServiceName)) { var service = serviceNameTable[consumedServiceName]; serviceTable[service].Add(consumer); if (service.SendMessageToNewSubscribers) { consumer.ConsumeServiceItem(service.RetrieveServiceItem(), service.GetServiceName()); } return(true); } else { if (stackIfServiceDoesNotExist) { //Add consumer to stack if (consumerStack.ContainsKey(consumedServiceName)) { consumerStack[consumedServiceName].Add(consumer); } else { consumerStack[consumedServiceName] = new List <IServiceConsumer <IServiceMessage> >() { consumer }; } //Debug.Log($"Service with the name {consumedServiceName} does not exist, consumer was stacked"); return(true); } //Debug.Log($"Service with the name {consumedServiceName} does not exist"); return(false); } }
/// <summary> /// Unregisters a service consumer if exists /// </summary> /// <param name="consumer"></param> /// <param name="consumedServiceName"></param> /// <returns></returns> public bool UnregisterServiceConsumer(IServiceConsumer <IServiceMessage> consumer, string consumedServiceName) { //Remove consumer from stack if it exists if (consumerStack.ContainsKey(consumedServiceName)) { consumerStack[consumedServiceName].Remove(consumer); if (consumerStack[consumedServiceName].Count == 0) { consumerStack.Remove(consumedServiceName); } } if (serviceNameTable.ContainsKey(consumedServiceName)) { serviceTable[serviceNameTable[consumedServiceName]].Remove(consumer); return(true); } else { //Debug.Log($"Service with the name {consumedServiceName} does not exist"); return(false); } }
public SteamBot(ILogProvider logProvider, IServiceConsumer <ISteamBotCoordinator> coordinator, SteamBotCoordinatorCallback callback) { ServiceName = "Keylol.SteamBot"; _logger = logProvider.Logger; Coordinator = coordinator; callback.SteamBot = this; _heartbeatTimer.Elapsed += (sender, args) => { try { Coordinator.Operations.Ping(); } catch (Exception e) { _logger.Warn("Ping failed.", e); Coordinator.Close(); } _heartbeatTimer.Start(); }; }
public ImageGarage(ILogProvider logProvider, MqClientProvider mqClientProvider, IServiceConsumer <IImageGarageCoordinator> coordinator) { ServiceName = "Keylol.ImageGarage"; _logger = logProvider.Logger; _mqChannel = mqClientProvider.CreateModel(); _coordinator = coordinator; Config.HtmlEncoder = new HtmlEncoderNone(); _heartbeatTimer.Elapsed += (sender, args) => { try { _coordinator.Operations.Ping(); } catch (Exception e) { _logger.Warn("Ping failed.", e); _coordinator.Close(); } _heartbeatTimer.Start(); }; }
/// <summary> /// Sets the retry policy. /// </summary> /// <typeparam name="TServiceInterface">The type of the service interface.</typeparam> /// <param name="serviceConsumer">The service consumer.</param> /// <param name="retryPolicy">The retry policy.</param> public static void SetRetryPolicy <TServiceInterface>(this IServiceConsumer <TServiceInterface> serviceConsumer, RetryPolicy retryPolicy) { serviceConsumer.RetryPolicy = new RetryPolicyAdapter(retryPolicy); }
public AgenteAdministracion() { proxy = ServiceConsumerFactory.Create <IServicioAdministracion>(() => new ServicioAdministracionClient()); }
/// <summary> /// Initializes a new instance of the <see cref="ConstructorInjectedController"/> class. /// </summary> /// <param name="fakeService">The fake service.</param> public ConstructorInjectedController(IServiceConsumer <IFakeService> fakeService) { this.FakeService = fakeService; }
/// <summary> /// Find all available services in all assemblies /// </summary> public void FindServices() { serviceConsumers = new Dictionary <Guid, ServiceConsumerInfo>(); AppDomainSetup setup = new AppDomainSetup(); setup.ApplicationName = "TempDomain"; setup.ApplicationBase = AppDomain.CurrentDomain.SetupInformation.ApplicationBase; setup.ConfigurationFile = AppDomain.CurrentDomain.SetupInformation.ConfigurationFile; setup.PrivateBinPath = AppDomain.CurrentDomain.SetupInformation.PrivateBinPath; setup.PrivateBinPathProbe = AppDomain.CurrentDomain.SetupInformation.PrivateBinPathProbe; AppDomain tempDomain = AppDomain.CreateDomain("TempDomain", AppDomain.CurrentDomain.Evidence, setup, AppDomain.CurrentDomain.PermissionSet, new StrongName[0]); var proxy = tempDomain.CreateInstanceAndUnwrap(Assembly.GetExecutingAssembly().FullName, typeof(LoadServiceTypesProxy).FullName) as LoadServiceTypesProxy; if (proxy == null) { Log.Error("Proxy is null!"); return; } // find all types which implement IServiceConsumer String path = (AppDomain.CurrentDomain.SetupInformation.PrivateBinPath ?? AppDomain.CurrentDomain.SetupInformation.ApplicationBase); DirectoryInfo binDir = new DirectoryInfo(path); Log.Debug("Scanning for service consumers in '" + binDir.FullName + "'."); foreach (FileInfo assemblyFile in binDir.GetFiles("*.dll")) { try { String assemblyName; String[] consumerTypes = proxy.LoadServiceTypes(assemblyFile.FullName, out assemblyName); foreach (String consumerType in consumerTypes) { IServiceConsumer consumer = tempDomain.CreateInstanceAndUnwrap(assemblyName, consumerType) as IServiceConsumer; if (consumer == null || String.IsNullOrEmpty(consumer.Name)) { Log.Error("Error instantiating type or consumer of type " + consumerType + " has an invalid name."); continue; } LoadConsumer(assemblyName, consumerType, consumer.Name); } } catch (BadImageFormatException) { // don't log those errors } catch (Exception ex) { Log.Error("ServiceManager.FindServices", ex); } } AppDomain.Unload(tempDomain); // create the apps for the services // store the service settings in the database SettingsManager settingsManager = new SettingsManager(); List <ServiceConsumerInfo> tempConsumers = new List <ServiceConsumerInfo>(ServiceConsumers.Values); foreach (ServiceConsumerInfo consumerInfo in tempConsumers) { IServiceConsumer consumer = consumerInfo.ServiceConsumer; try { // save default authentication settings if they don't exist AuthSettingsBase authSettings = settingsManager.GetServiceSettings(consumerInfo.Id); if (authSettings == null || authSettings.GetType().Name != consumer.Settings.GetType().Name) { settingsManager.SaveServiceSettings(consumerInfo.Id, consumer.Settings); } else { consumer.Settings = authSettings; } } catch (Exception ex) { Log.Error("ServiceManager.FindServices.InitializeConsumer", ex); UnloadConsumer(consumerInfo); } } }
public TestController(ILogger <TestController> logger, IServiceConsumer serviceConsumer) { _logger = logger; _svcConsumer = serviceConsumer; }