private void ReplaceType <T>(BuildUp <T> buildMethod)
{
lock (_dictionaryLock)
{
_dictionary[typeof(T)] = new ServiceBuilder <T>(buildMethod);
};
}
private static void Run <T>(ServiceBuilder <T> builder, Action <HostConfigurator> config)
where T : class, ServiceControl
{
var tuple = builder.Build();
HostFactory.Run(
host =>
{
// recovery
host.EnableServiceRecovery(
recovery =>
{
recovery.RestartService(0);
recovery.SetResetPeriod(1);
});
// common dependecies.
host.DependsOn("RabbitMQ");
// control
host.UseUnityContainer(tuple.Item1);
host.Service <T>(
s =>
{
s.ConstructUsingUnityContainer();
s.WhenStarted((service, control) => service.Start(control));
s.WhenStopped((service, control) => service.Stop(control));
});
config(host);
});
}
private void InitInfrastructureServices()
{
try
{
// Cargar todos los modelos de datos y verificar ensamblados
DataModelDataAccess dataModelDataAccess = new DataModelDataAccess();
Collection <DataModelEntity> result = dataModelDataAccess.LoadWhere(DataModelEntity.DBIdStore, "0", false, OperatorType.Equal);
dataModelDataAccess = new DataModelDataAccess();
Collection <DataModelEntity> dataModels = dataModelDataAccess.LoadAll(true);
if (result.Count == 0)
{
ConsoleWriter.SetText("Creating mall data model");
DataModelEntity dataModel = new DataModelEntity();
MallEntity mall = new MallEntity();
mall.MallName = "Mall";
(new MallDataAccess()).Save(mall);
dataModel.Mall = mall;
dataModelDataAccess.Save(dataModel);
}
foreach (DataModelEntity dataModel in dataModels)
{
string assemblyFileName = dataModel.ServiceAssemblyFileName;
if (assemblyFileName != null)
{
if (File.Exists(Path.Combine(ServiceBuilder.AssembliesFolder, assemblyFileName)))
{
Type[] servicesTypes = ServiceBuilder.GetInfrastructureServiceTypes(assemblyFileName);
Binding serviceBinding = new BasicHttpBinding();
if (PublishInfrastructureService(servicesTypes[0], servicesTypes[1], serviceBinding))
{
Debug.WriteLine("SUCCESS : infrastructure service published.");
}
else
{
Debug.WriteLine("FAILURE : trying to publish infrastructure service.");
}
}
else
{
ServiceBuilder builder = new ServiceBuilder();
dataModel.Deployed = false;
builder.BuildAndImplementInfrastructureService(dataModel, false, serverSession);
}
}
}
}
catch (DataException dataError)
{
Debug.WriteLine("ERROR : Data exception running infrastructure services. MESSAGE : " + dataError.Message);
}
catch (IOException ioError)
{
Debug.WriteLine("ERROR : IO error running infrastructure services. MESSAGE : " + ioError.Message);
}
}
public DeliveryStatusUpdateServiceTest()
{
IServiceProvider _serviceProvider = ServiceBuilder.getServiceProviderWithInMemoryDatabase();
context = _serviceProvider.GetRequiredService <ApplicationDbContext>();
statusUpdateService = new DeliveryStatusUpdateService(context);
}
public void ProxyService_Click(object sender, RoutedEventArgs args)
{
//var proxy = await ServiceBuilder.Proxy<IFactoryService>(this)
//var proxy = await ServiceBuilder.Proxy(new CustomDuplexChannelFactory<IFactoryService>(this))
//var proxy = await ServiceBuilder.Proxy((endpoint) => new CustomDuplexChannelFactory<IFactoryService>(this, endpoint))
//var proxy = ServiceBuilder.Proxy(this, (instance, endpoint) => new CustomDuplexChannelFactory<IFactoryService>(instance, endpoint))
var proxy = ServiceBuilder.Proxy <IFactoryService>(this)
.DefaultTcpSecurizedProxy("localhost", 6666, "FactoryService", "fuxion.demo", "username", "password", "0DFF4D21124E15D8B3365B03E65AE4B9F4A52FF3")
.Create();
//.OpenAsync(afterOpenAction: _ => Debug.WriteLine($"{Thread.CurrentThread.ManagedThreadId} - Proxy opened"));
Stopwatch sw = new Stopwatch();
sw.Start();
((ICommunicationObject)proxy).Open();
Debug.WriteLine("Open WATCH: " + sw.ElapsedMilliseconds);
sw.Restart();
proxy.Ping();
Debug.WriteLine("Ping WATCH: " + sw.ElapsedMilliseconds);
Debug.WriteLine($"{Thread.CurrentThread.ManagedThreadId} - Proxy ping call completed");
/*
* To allow the self signed certificate must add this to app.config or web.config
* <configuration>
* <runtime>
* <AppContextSwitchOverrides value="Switch.System.IdentityModel.DisableMultipleDNSEntriesInSANCertificate=true" />
* </runtime>
* </configuration>
*/
return;
}
public void Build(ContainerBuilder serviceContainer)
{
var serviceBuilder = new ServiceBuilder(serviceContainer);
var virtualPaths = new List <string>();
if (_serviceEngine != null)
{
if (_serviceEngine.ModuleServiceLocationFormats != null)
{
var paths = GetPaths(_serviceEngine.ModuleServiceLocationFormats);
if (paths == null)
{
return;
}
serviceBuilder.RegisterServices(paths);
serviceBuilder.RegisterRepositories(paths);
}
if (_serviceEngine.ComponentServiceLocationFormats != null)
{
var paths = GetPaths(_serviceEngine.ComponentServiceLocationFormats);
if (paths == null)
{
return;
}
serviceBuilder.RegisterModules(paths);
}
}
}
public void Add(Action <IServiceBuilderFor> serviceAction)
{
var service = new ServiceBuilder();
stratagies.Add(service);
serviceAction(service);
}
public static async Task Main(string[] args)
{
var configuration = new ConfigurationBuilder()
.AddJsonFile("appsettings.json", optional: true, reloadOnChange: true)
.Build();
var builder = new ServiceBuilder();
builder.Configure <GatewayConfiguration>((config) =>
{
configuration.GetSection("Gateway").Bind(config);
});
builder.AddDefaultServices();
builder.AddGatewayServices();
builder.AddLog(configuration);
builder.Build();
await builder.RunGatewayAsync();
while (true)
{
await Task.Delay(1000).ConfigureAwait(false);
}
}
public void SetUp()
{
service = ServiceBuilder <MercadoLibreOptions> .GetService <MonedasApiService>();
loggingService = new CsvLoggingService(new OptionsMock <CsvLoggingOptions>(OptionsMockBuilder.GetOptions <CsvLoggingOptions>()));
Handler = new ObtenerConversionHandler(Logger, service, loggingService, Mapper);
}
public static void Describe(this IList <IServiceDescriptor> descriptors, ServiceBuilder builder)
{
for (var i = 0; i < descriptors.Count; i++)
{
descriptors[i].Describe(builder);
}
}
public void SetUp()
{
obtenerPagoApiService = ServiceBuilder <MercadoLibreOptions> .GetService <PaisesApiService>();
Handler = new ObtenerPaisesHandler(Logger, obtenerPagoApiService, Mapper);
request = new ObtenerPaisesRequest();
}
public override Host Build()
{
if (ServiceBuilders.Count > 1)
{
throw new HostConfigurationException("A shelf can only have one service configured");
}
ServiceBuilder builder = ServiceBuilders.Single();
_log.DebugFormat("[Shelf:{0}] Building Service: {1}", Description.Name, builder.Name);
var controllerFactory = new ServiceControllerFactory();
ActorFactory <IServiceController> factory = controllerFactory.CreateFactory(inbox =>
{
var publish = new PublishChannel(_channel, inbox);
IServiceController service = builder.Build(inbox, publish);
return(service);
});
ActorRef instance = factory.GetActor();
_channel.Connect(x => x.AddChannel(instance));
// this creates the state machine instance in the shelf and tells the servicecontroller
// to create the service
instance.Send(new CreateService(Description.Name));
return(new ShelfHost(instance));
}
public static ServiceBuilderFactory CreateServiceBuilderFactory <TService>(
Func <HostSettings, TService> serviceFactory,
Action <ServiceConfigurator> callback)
where TService : class, ServiceControl
{
if (serviceFactory == null)
{
throw new ArgumentNullException(nameof(serviceFactory));
}
if (callback == null)
{
throw new ArgumentNullException(nameof(callback));
}
var serviceConfigurator = new ControlServiceConfigurator <TService>(serviceFactory);
callback(serviceConfigurator);
ServiceBuilder ServiceBuilderFactory(HostSettings x)
{
ConfigurationResult configurationResult = ValidateConfigurationResult.CompileResults(serviceConfigurator.Validate());
if (configurationResult.Results.Any())
{
throw new HostConfigurationException("The service was not properly configured");
}
ServiceBuilder serviceBuilder = serviceConfigurator.Build();
return(serviceBuilder);
}
return(ServiceBuilderFactory);
}
public Host CreateHost()
{
Type type = typeof(HostFactory);
HostLogger.Get <HostConfiguratorImpl>()
.InfoFormat("{0} v{1}, .NET Framework v{2}", type.Namespace, type.Assembly.GetName().Version,
Environment.Version);
EnvironmentBuilder environmentBuilder = _environmentBuilderFactory(this);
HostEnvironment environment = environmentBuilder.Build();
ServiceBuilder serviceBuilder = _serviceBuilderFactory(_settings);
HostBuilder builder = _hostBuilderFactory(environment, _settings);
foreach (HostBuilderConfigurator configurator in _configurators)
{
builder = configurator.Configure(builder);
}
try
{
return(builder.Build(serviceBuilder));
}
//Intercept exceptions from serviceBuilder, TopShelf handling is in HostFactory
catch (Exception ex)
{
builder.Settings?.ExceptionCallback(ex);
throw;
}
}
public ActionResult Details(string msg)
{
bool isHasNoActive
= Request.Cookies[GLB.userId] != null && Convert.ToInt32(Request.Cookies[GLB.depId].Value) == GLB.adminDepId ? true : false;
ResponseStatus resp = activityService.GetActivities(conta_Activity, isHasNoActive);
Container_Authority_Msg auth = new Container_Authority_Msg();
ResponseStatus resp1 = ServiceBuilder.BuildAuthService().GetSecondAuth(Request.Cookies, auth);
if (resp1 == ResponseStatus.FAILED)
{
resp = resp1;
}
//if (Request.Cookies[GLB.userId] != null) Response.
return(this.JudgeResult(resp, () =>
{
conta_Activity.msg = msg;
conta_Activity.isAdd = auth.isAdd;
conta_Activity.isDelete = auth.isDelete;
conta_Activity.isUpdate = auth.isUpdate;
conta_Activity.isVisit = auth.isVisit;
if (auth.isVisit)
{
return View("Details_Visit", conta_Activity);
}
else
{
return View(conta_Activity);
}
}));
}
protected internal virtual void startProcessEngine(ProcessEngineXml processEngineXml, DeploymentPhaseContext phaseContext)
{
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final org.jboss.msc.service.ServiceTarget serviceTarget = phaseContext.getServiceTarget();
ServiceTarget serviceTarget = phaseContext.ServiceTarget;
// transform configuration
ManagedProcessEngineMetadata configuration = transformConfiguration(processEngineXml);
// validate the configuration
configuration.validate();
// create service instance
MscManagedProcessEngineController service = new MscManagedProcessEngineController(configuration);
// get the service name for the process engine
ServiceName serviceName = ServiceNames.forManagedProcessEngine(processEngineXml.Name);
// get service builder
ServiceBuilder <ProcessEngine> serviceBuilder = serviceTarget.addService(serviceName, service);
// make this service depend on the current phase -> makes sure it is removed with the phase service at undeployment
serviceBuilder.addDependency(phaseContext.PhaseServiceName);
// add Service dependencies
MscManagedProcessEngineController.initializeServiceBuilder(configuration, service, serviceBuilder, processEngineXml.JobAcquisitionName);
// install the service
serviceBuilder.install();
}
public ActionResult GetUserTimeTable()
{
timeTabSer = ServiceBuilder.BuildTimeTableService();
timeTabSer.UpdateBefore(Request, container_TimeTables_UserBases);
timeTabSer.GetOtherDetails(Request, container_TimeTables_UserBases);
return(View("Update", container_TimeTables_UserBases));
}
public SettingsWindow(ServiceBuilder serviceBuilder, HotKeysBuilder hotKeysBuilder)
{
InitializeComponent();
serverPortConverter = new IntConverter();
clientPortConverter = new IntNullableConverter()
{
AutoParseNullOrWhiteSpace = true,
NullOrWhiteSpaceValue = null
};
timMode.DataContext = ServiceBuilder = serviceBuilder;
timHotKeys.DataContext = HotKeysBuilder = hotKeysBuilder;
if (serviceBuilder.BuildServer)
{
tbxPort.Text = serverPortConverter.Convert(serviceBuilder.ServerPort);
}
else if (serviceBuilder.BuildClient)
{
tbxPort.Text = clientPortConverter.Convert(serviceBuilder.ClientPort);
}
if (!serviceBuilder.IsSearchShuffle.HasValue)
{
cbxSearchShuffle.IsChecked = null;
}
if (!serviceBuilder.Play.HasValue)
{
cbxPlay.IsChecked = null;
}
}
public ActionResult GameOrderTopology(double firstCount, string gameId)
{
try
{
ViewBag.FirstCount = firstCount;
//比赛轮次
Request <Game> reqOrder = new Request <Game>();
reqOrder.Token = CurrentUser.Token;
reqOrder.Filter = new Game {
Id = gameId
};
var resOrder = ServiceBuilder.GetInstance().Execute(ServiceType.GetGameOrderList, reqOrder);
var lst = (from p in resOrder.Entities where (p as GameOrder).KnockoutOption == KnockoutOption.KNOCKOUT.Id select p as GameOrder).ToList();
ViewBag.GameOrderLst = lst;
//比赛对阵详情
Request <GetGameOrderLoopListFilter> request = new Request <GetGameOrderLoopListFilter>();
request.Token = CurrentUser.Token;
request.Filter = new GetGameOrderLoopListFilter {
GameId = gameId, IsExtra = "0"
};
var result = ServiceBuilder.GetInstance().Execute(ServiceType.GetGameOrderLoopList, request);
return(View(result.Entities));
}
catch (Exception ex)
{
return(this.RedirectToErrorPage(ex.Message));
}
}
public ActionResult Details(int?curpage, string message)
{
visitPaginate.CurrentPage = curpage == null ? 1 : (int)curpage;
conta_List_Visit = new Container_List_Visit()
{
paginate = visitPaginate,
msg = message
};
ResponseStatus resp = visitService.GetVisits(conta_List_Visit);
Container_Authority_Msg auth = new Container_Authority_Msg();
ResponseStatus resp1 = ServiceBuilder.BuildAuthService().GetSecondAuth(Request.Cookies, auth);
if (resp1 == ResponseStatus.FAILED)
{
resp = resp1;
}
return(base.JudgeResult(resp,
() => {
conta_List_Visit.isAdd = auth.isAdd;
conta_List_Visit.isDelete = auth.isDelete;
conta_List_Visit.isUpdate = auth.isUpdate;
conta_List_Visit.isVisit = auth.isVisit;
return View(conta_List_Visit);
}));
}
public JsonResult GameTeamCheckSave(string id, string auditRemark, string state)
{
try
{
Request <GameTeam> request = new Request <GameTeam>();
request.Token = CurrentUser.Token;
request.Entities = new List <GameTeam> {
new GameTeam {
Id = id,
AuditorId = CurrentUser.Id,
AuditRemark = auditRemark,
AuditDate = DateTime.Now,
State = state
}
};
var result = ServiceBuilder.GetInstance().Execute(ServiceType.AuditGameTeam, request);
return(ToJson(result));
}
catch (Exception ex)
{
var errResult = ResultHelper.Fail(ex.Message);
return(ToJson(errResult));
}
}
public JsonResult GameOrderCreate(string gameId, int groupCount, int knockoutCount, string knockoutId)
{
try
{
Request <GameOrder> request = new Request <GameOrder>();
request.Token = CurrentUser.Token;
request.Entities = new List <GameOrder> {
new GameOrder {
GameId = gameId,
GroupCount = groupCount,
KnockoutCount = knockoutCount,
KnockoutOption = knockoutId,
RowState = RowState.Added
}
};
var result = ServiceBuilder.GetInstance().Execute(ServiceType.CreateGameOrder, request);
return(ToJson(result));
}
catch (Exception ex)
{
var errResult = ResultHelper.Fail(ex.Message);
return(ToJson(errResult));
}
}
T exec <T>(IReadOnlyContainer container)
{
IServiceRegistration serviceRegistration = new ServiceRegistrationBuilder()
.AddType(typeof(T))
.Build();
ServiceFlags flags = new ServiceFlagsProvider(new AttributesFinder(), new MemberGenerator(new MemberFlagsGenerator())).ProvideFlags(typeof(T));
IService service = new ServiceBuilder()
.AddRegistration(serviceRegistration)
.AddFlags(flags)
.AddInfo(null)
.Build();
object instance = Activator.CreateInstance <T>();
ObjectPostProcessor postProcessor = new ObjectPostProcessor(new InstanceMembersValueInjector(new MemberValueSetter(), new InstanceMembersFinder()),
new InjectMemberValuesInjector(new MemberValueSetter(), new InjectFlagsProvider(), new MemberDeclarationTypeProvider(), new InjectValueProvider()),
new TryInjectMemberValuesInjector(new ServiceAttributeProvider(), new MemberDeclarationTypeProvider(),
new MemberValueSetter(), new InjectValueProvider()),
new AutoMemberValuesInjector(new MemberDeclarationTypeProvider(), new ServiceAttributeProvider(),
new AutoValueGenerator(
new IsEnumerableChecker(new GenericTypeGenerator(), new TypeGenericParametersProvider(), new TypeContainsGenericParametersChecker()),
new EnumerableGenerator(new TypeGenericParametersProvider(), new GenericTypeGenerator()), new TypeIsArrayChecker(),
new ArrayGenerator(), new TypeIsValueTypeChecker(), new ValueTypeActivator()), new MemberValueSetter()));
postProcessor.Process(instance, service, container);
return((T)instance);
}
public void SetUp()
{
service = ServiceBuilder <ChallengeDbContext, UserEntity> .GetService <UserDbService>();
Handler = new InsertarUsuarioHandler(Logger, service, Mapper);
user = UserMock.UserModelMock();
}
public static void ConfigureService(ServiceBuilder <BusServiceControl> builder)
{
builder
.ConfigureContainer(
cfg =>
{
cfg.RegisterType <IEncryptor, Encryptor>();
cfg.RegisterInstance((ILdapConfig)ConfigurationManager.GetSection("ldap"));
cfg.RegisterType <ILdapService, LdapService>();
})
.ConfigureBus(
(cfg, host, container) =>
{
cfg.UseTickets(container.Resolve <Encryptor>());
cfg.ReceiveEndpoint(
host,
WellKnownQueues.Ldap,
e =>
{
//e.AutoDelete = true;
//e.Durable = false;
e.Consumer(() => container.Resolve <UserConsumer>());
e.Consumer(() => container.Resolve <UserGroupConsumer>());
e.Consumer(() => container.Resolve <DepartmentConsumer>());
});
},
bus =>
{
// Cross-services SSO
bus.ConnectThreadPrincipal();
});
}
public void FillServiceBuilder(ServiceBuilder builder)
{
if (BuildStandalone)
{
builder.WithStandalone();
}
else if (BuildServer)
{
builder.WithServer(ServerPort);
}
else if (BuildClient)
{
builder.WithClient(ServerAddress, ClientPort);
}
builder
.WithCommunicatorProtocol(CommunicatorProtocol)
.WithShuffle((OrderType?)Shuffle)
.WithIsSearchShuffle(IsSearchShuffle)
.WithPlay(Play)
.WithIsStreaming(IsStreaming)
.WithServerPort(ServerPort)
.WithClientPort(ClientPort)
.WithSearchKey(SearchKey)
.WithServerAddress(ServerAddress)
.WithVolume(Volume);
}
public ActionResult SameunitSet(string gameId, string teamId, string teamName)
{
try
{
List <GameTeam> lst = new List <GameTeam>();
var request = new Request <GetGameTeamListFilter>();
request.Token = CurrentUser.Token;
request.Filter = new GetGameTeamListFilter {
GameId = gameId, OnlyNotGroup = false, PageIndex = 1, PageSize = 1000
};
var result = ServiceBuilder.GetInstance().Execute(ServiceType.GetGameTeamList, request);
result.Entities.ForEach(p =>
{
if (p.Id != teamId)
{
lst.Add(p as GameTeam);
}
});
ViewBag.GameId = gameId;
ViewBag.TeamId = teamId;
ViewBag.TeamName = teamName;
return(View(lst));
}
catch (Exception ex)
{
return(this.RedirectToErrorPage(ex.Message));
}
}
public ActionResult Login()
{
userService = ServiceBuilder.BuildUserService();
UserStatus us = null;
ResponseStatus rspStatus = userService.Login(Request, conTa_status, ref us);
if (rspStatus == ResponseStatus.SUCCESS)
{
CookieFactory cf = CookieFactory.Instance();
cf.CreateCookie(GLB.userId, us.UserID, DateTime.Now.AddYears(1), Response);
cf.CreateCookie(GLB.userName, us.UserName, DateTime.Now.AddYears(1), Response);
cf.CreateCookie(GLB.id, us.ID.ToString(), DateTime.Now.AddYears(1), Response);
cf.CreateCookie(GLB.depId, us.Dep.ID.ToString(), DateTime.Now.AddYears(1), Response);
GLB.Instance().GetActivitiesIdCookies(Response, DateTime.Now.AddYears(1));
return(RedirectToAction("PersonalHome"));
}
else if (rspStatus == ResponseStatus.NOT_PASS)
{
return(RedirectToAction("Message", "Other", new { msg = Msg.NotPass }));
}
else if (rspStatus == ResponseStatus.NOT_REGISTER)
{
return(RedirectToAction("Message", "Other", new { msg = Msg.NotReg }));
}
else if (rspStatus == ResponseStatus.REQFORM_COUNT_ISZERO)
{
return(View());
}
return(View());
}
public IProcess MakeProcess(uint processId)
{
Process process = new Process(processId, Host);
ServiceBuilder serviceBuilder = new ServiceBuilder(process);
foreach(var b in buildSteps)
{
b(serviceBuilder);
}
process.DefineExtensions(serviceBuilder);
PlacementBuilder placementBuilder = new PlacementBuilder(process, NumberProcesses);
foreach (var p in serviceBuilder.Placements)
{
p(placementBuilder);
}
process.FinalizePlacement();
process.Serializer = new Serializer(Host.SerializableTypes);
process.DeepCopier = new DefaultDeepCopier(Host);
process.Telemetry = Host.GetTelemetryListener();
process.ConfigureLogging();
process.ClearState();
return process;
}
public static HostConfigurator Service <TService>(this HostConfigurator configurator,
Action <ServiceConfigurator <TService> > callback)
where TService : class
{
if (configurator == null)
{
throw new ArgumentNullException("configurator");
}
if (callback == null)
{
throw new ArgumentNullException("callback");
}
var serviceConfigurator = new DelegateServiceConfigurator <TService>();
callback(serviceConfigurator);
configurator.UseServiceBuilder(x =>
{
ConfigurationResult configurationResult =
ValidateConfigurationResult.CompileResults(serviceConfigurator.Validate());
if (configurationResult.Results.Any())
{
throw new HostConfigurationException("The service was not properly configured");
}
ServiceBuilder serviceBuilder = serviceConfigurator.Build();
return(serviceBuilder);
});
return(configurator);
}
private static void Run()
{
using (var serviceBuilder = new ServiceBuilder())
{
serviceBuilder.BuildApplication();
SpinWait.SpinUntil(() => ProcessSpecialKey(Console.ReadKey()));
}
}
public void fill_into_will_not_overwrite_the_parent_if_it_exists()
{
var services1 = new ServiceBuilder();
var services2 = new ServiceBuilder();
services1.Add<IChrome>(() => new AChrome());
services2.Add<IChrome>(() => new BChrome());
services2.FillInto(services1);
services1.Build<IChrome>().ShouldBeOfType<AChrome>();
}
public void importing_services()
{
var builder1 = new ServiceBuilder();
var builder2 = new ServiceBuilder();
builder1.Add(() => "blue");
builder2.Add(() => "green");
builder2.Add(() => 1);
builder2.FillInto(builder1);
builder1.Build<string>().ShouldEqual("blue"); // not replaced
builder1.Build<int>().ShouldEqual(1); // was filled in
}
