Beispiel #1
0
        /// <summary>
        /// Create engine
        /// </summary>
        /// <param name="messageTrigger"></param>
        /// <param name="encoder"></param>
        /// <param name="messageSink"></param>
        /// <param name="engineConfiguration"></param>
        /// <param name="logger"></param>
        public DataFlowProcessingEngine(IMessageTrigger messageTrigger, IMessageEncoder encoder,
                                        IMessageSink messageSink, IEngineConfiguration engineConfiguration, ILogger logger)
        {
            _messageTrigger = messageTrigger;
            _messageSink    = messageSink;
            _messageEncoder = encoder;
            _logger         = logger;

            _messageTrigger.OnMessage += MessageTriggerMessageReceived;

            if (engineConfiguration.DiagnosticsInterval.HasValue &&
                engineConfiguration.DiagnosticsInterval > TimeSpan.Zero)
            {
                _diagnosticsOutputTimer = new Timer(DiagnosticsOutputTimer_Elapsed, null, 0,
                                                    (int)engineConfiguration.DiagnosticsInterval.Value.TotalMilliseconds);
            }

            if (engineConfiguration.BatchSize.HasValue &&
                engineConfiguration.BatchSize.Value > 1)
            {
                _dataSetMessageBufferSize = engineConfiguration.BatchSize.Value;
            }
            if (engineConfiguration.MaxMessageSize.HasValue &&
                engineConfiguration.MaxMessageSize.Value > 0)
            {
                _maxEncodedMessageSize = engineConfiguration.MaxMessageSize.Value;
            }
        }
Beispiel #2
0
        /// <summary>
        /// Create engine
        /// </summary>
        /// <param name="messageTrigger"></param>
        /// <param name="encoder"></param>
        /// <param name="messageSink"></param>
        /// <param name="engineConfiguration"></param>
        /// <param name="logger"></param>
        /// <param name="identity"></param>
        public DataFlowProcessingEngine(IMessageTrigger messageTrigger, IMessageEncoder encoder,
                                        IMessageSink messageSink, IEngineConfiguration engineConfiguration, ILogger logger,
                                        IIdentity identity)
        {
            _config         = engineConfiguration;
            _messageTrigger = messageTrigger;
            _messageSink    = messageSink;
            _messageEncoder = encoder;
            _logger         = logger;
            _identity       = identity;

            if (_config.BatchSize.HasValue && _config.BatchSize.Value > 1)
            {
                _dataSetMessageBufferSize = _config.BatchSize.Value;
            }
            if (_config.MaxMessageSize.HasValue && _config.MaxMessageSize.Value > 0)
            {
                _maxEncodedMessageSize = _config.MaxMessageSize.Value;
            }

            _diagnosticInterval        = _config.DiagnosticsInterval.GetValueOrDefault(TimeSpan.Zero);
            _batchTriggerInterval      = _config.BatchTriggerInterval.GetValueOrDefault(TimeSpan.Zero);
            _diagnosticsOutputTimer    = new Timer(DiagnosticsOutputTimer_Elapsed);
            _batchTriggerIntervalTimer = new Timer(BatchTriggerIntervalTimer_Elapsed);
        }
 public GenerationConfiguration(IEngineConfiguration configuration, IEngineConventionProvider conventionProvider,
     int recursionLimit)
 {
     mConfiguration = configuration;
     mConventions = conventionProvider;
     RecursionLimit = recursionLimit;
 }
 public void AddTypesAndBuild()
 {
     this.Builder.Include<SimpleUser>();
     this.Builder.Include<SimplePropertyClass>();
     this.Builder.Include<SimpleFieldClass>();
     this.Configuration = new EngineConfigurationFactory().Create(this.Builder, this.Builder.ConventionProvider);
 }
Beispiel #5
0
        /// <summary>
        /// Create engine
        /// </summary>
        /// <param name="messageTrigger"></param>
        /// <param name="encoder"></param>
        /// <param name="messageSink"></param>
        /// <param name="engineConfiguration"></param>
        /// <param name="logger"></param>
        /// <param name="identity"></param>
        public DataFlowProcessingEngine(IMessageTrigger messageTrigger, IMessageEncoder encoder,
                                        IMessageSink messageSink, IEngineConfiguration engineConfiguration, ILogger logger,
                                        IIdentity identity)
        {
            _config         = engineConfiguration;
            _messageTrigger = messageTrigger;
            _messageSink    = messageSink;
            _messageEncoder = encoder;
            _logger         = logger;
            _identity       = identity;

            if (_config.BatchSize.HasValue && _config.BatchSize.Value > 1)
            {
                _dataSetMessageBufferSize = _config.BatchSize.Value;
            }
            if (_config.MaxMessageSize.HasValue && _config.MaxMessageSize.Value > 0)
            {
                _maxEncodedMessageSize = _config.MaxMessageSize.Value;
            }

            _diagnosticInterval        = _config.DiagnosticsInterval.GetValueOrDefault(TimeSpan.Zero);
            _batchTriggerInterval      = _config.BatchTriggerInterval.GetValueOrDefault(TimeSpan.Zero);
            _diagnosticsOutputTimer    = new Timer(DiagnosticsOutputTimer_Elapsed);
            _batchTriggerIntervalTimer = new Timer(BatchTriggerIntervalTimer_Elapsed);
            _maxEgressMessageQueue     = _config.MaxEgressMessageQueue.GetValueOrDefault(4096); // = 2 GB / 2 / (256 * 1024)
            _logger.Information($"Max. egress message queue: {_maxEgressMessageQueue} messages ({_maxEgressMessageQueue * 256 / 1024} MB)");
        }
Beispiel #6
0
        public SchedulerConsoleSettings(IApplicationContext context, IEngineConfiguration engineConfig, IApplicationConfiguration appConfig)
        {
            InstanceId                  = context.InstanceId.ToString();
            InstanceName                = appConfig.ApplicationName;
            StartEngineImmediately      = engineConfig.IsImmediateEngineStartEnabled;
            EnableJobsDirectoryTracking = engineConfig.IsJobsDirectoryTrackingEnabled;
            JobsDirectory               = engineConfig.JobsDirectory;

            EngineStarted    = (sender, e) => { ConsoleApi.WriteLine("The engine has been started..."); };
            EnginePaused     = (sender, e) => { ConsoleApi.WriteLine("The engine has been paused..."); };
            EngineTerminated = (sender, e) => { ConsoleApi.WriteLine("The engine has been terminated..."); };

            JobScheduled   = (sender, e) => { ConsoleApi.WriteLine($"The job (Name:{e.Job.Name}, Group:{e.Job.Group}) has been scheduled"); };
            JobUnscheduled = (sender, e) => { ConsoleApi.WriteLine($"The job (Name:{e.Job.Name}, Group:{e.Job.Group}) has been unscheduled"); };
            JobPaused      = (sender, e) => { ConsoleApi.WriteLine($"The job (Name:{e.Job.Name}, Group:{e.Job.Group}) has been put on hold"); };
            JobResumed     = (sender, e) => { ConsoleApi.WriteLine($"The job (Name:{e.Job.Name}, Group:{e.Job.Group}) has been resumed"); };
            JobTriggered   = (sender, e) => { ConsoleApi.WriteLine($"The job (Name:{e.Job.Name}, Group:{e.Job.Group}) has been triggered"); };

            JobExecutionSucceeded = (sender, e) => { ConsoleApi.WriteLine($"The job (Name:{e.Job.Name}, Group:{e.Job.Group}) has finished with status: SUCCESS"); };
            JobExecutionFailed    = (sender, e) => { ConsoleApi.WriteLine($"The job (Name:{e.Job.Name}, Group:{e.Job.Group}) has finished with status: FAILED"); };
            JobExecutionSkipped   = (sender, e) => { ConsoleApi.WriteLine($"The job (Name:{e.Job.Name}, Group:{e.Job.Group}) execution has been skipped"); };

            BeforeJobExecution = (sender, e) => { ConsoleApi.WriteLine($"The job (Name:{e.Job.Name}, Group:{e.Job.Group}) is going to be executed"); };
            AfterJobExecution  = (sender, e) => { ConsoleApi.WriteLine($"The job (Name:{e.Job.Name}, Group:{e.Job.Group}) has been executed"); };
        }
Beispiel #7
0
        public IEngine Setup(Func <IMutableEngineConfiguration> creator, Action <IMutableEngineConfiguration> configurator)
        {
            if (creator == null)
            {
                throw new ArgumentNullException("creator");
            }
            if (configurator == null)
            {
                throw new ArgumentNullException("configurator");
            }
            IMutableEngineConfiguration config = creator();

            if (config == null)
            {
                throw new InvalidOperationException("config from creator() is null");
            }
            _config = config;
            configurator(config);
            _globalContext = config.ContextProvider();
            _plan          = config.PlanProvider();
            foreach (var action in _config.Actions)
            {
                action.SetEngine(this);
            }
            return(this);
        }
Beispiel #8
0
        public IPlan GetPlan(IEngineConfiguration config)
        {
            if (config == null)
            {
                throw new ArgumentNullException("config");
            }

            ActionGraph                     graph          = new ActionGraph(config);
            IEnumerable <IAction>           actionsInOrder = graph.GetActionsInDependencyOrder();
            IObservable <IElement>          root           = System.Linq.Enumerable.Empty <IElement>().AsObservable();
            IList <IEnumerable <IElement> > finals         = new List <IEnumerable <IElement> >();

            foreach (IAction action in actionsInOrder)
            {
                if (graph.GetPrevActionsCount(action) > 0)
                {
                    var outputs = graph.GetPrevActions(action).Select(x => x.Output.AsEnumerable());
                    action.SetInput(outputs.Merge().AsObservable());
                }
                else
                {
                    action.SetInput(root);
                }
                if (graph.GetNextActionsCount(action) == 0)
                {
                    finals.Add(action.Output.AsEnumerable());
                }
            }

            return(new EnumerablePlan(finals.Merge()));
        }
Beispiel #9
0
        /// <summary>
        /// Creates a <see cref="RazorLightEngine"/> that resolves templates inside given type assembly as a EmbeddedResource
        /// with a given <see cref="IEngineConfiguration"/>
        /// </summary>
        /// <param name="rootType">Root type where resource is located</param>
        /// <param name="configuration">Engine configuration</param>
        public static RazorLightEngine CreateEmbedded(Type rootType, IEngineConfiguration configuration)
        {
            ITemplateManager manager = new EmbeddedResourceTemplateManager(rootType);
            var dependencies         = CreateDefaultDependencies(manager, configuration);

            return(new RazorLightEngine(dependencies.Item1, dependencies.Item2));
        }
 public void AddTypesAndBuild()
 {
     this.Builder.Include <SimpleUser>();
     this.Builder.Include <SimplePropertyClass>();
     this.Builder.Include <SimpleFieldClass>();
     this.Configuration = new EngineConfigurationFactory().Create(this.Builder, this.Builder.ConventionProvider);
 }
        protected virtual IEnumerable<IEngineConfigurationTypeMember> GetAllTypeHierarchyMembers(IEngineConfiguration baseConfiguration, IEngineConfigurationType sourceType)
        {
            Stack<IEngineConfigurationType> configurationStack = new Stack<IEngineConfigurationType>();
            Type currentType = sourceType.RegisteredType;
            IEngineConfigurationType currentTypeConfiguration = null;

            // Get all the base types into a stack, where the base-most type is at the top
            while (currentType != null)
            {
                currentTypeConfiguration = baseConfiguration.GetRegisteredType(currentType);
                if (currentTypeConfiguration != null) { configurationStack.Push(currentTypeConfiguration); }
                currentType = currentType.BaseType;
            }

            // Put all the implemented interfaces on top of that
            foreach (var interfaceType in sourceType.RegisteredType.GetInterfaces())
            {
                currentTypeConfiguration = baseConfiguration.GetRegisteredType(interfaceType);
                if (currentTypeConfiguration != null)
                {
                    configurationStack.Push(currentTypeConfiguration);
                }
            }

            var membersToApply = (from typeConfig in configurationStack
                                  from memberConfig in typeConfig.GetRegisteredMembers()
                                  select memberConfig).ToArray();

            return membersToApply;
        }
Beispiel #12
0
 /// <summary>
 /// Create converter
 /// </summary>
 /// <param name="logger"></param>
 /// <param name="config"></param>
 /// <param name="cryptoProvider"></param>
 public PublishedNodesJobConverter(ILogger logger,
                                   IEngineConfiguration config = null, ISecureElement cryptoProvider = null)
 {
     _config         = config;
     _cryptoProvider = cryptoProvider;
     _logger         = logger ?? throw new ArgumentNullException(nameof(logger));
 }
Beispiel #13
0
        public void Ensure_Passed_Configuration_Is_Applided_OnPhysical()
        {
            IEngineConfiguration configuration = EngineConfiguration.Default;

            var engine = EngineFactory.CreatePhysical(viewsRoot, configuration);

            Assert.Same(configuration, engine.Configuration);
        }
 public RazorEngineCore(ReadOnlyEngineConfiguration config)
 {
     if (config == null)
     {
         throw new ArgumentNullException(nameof(config));
     }
     this.Configuration = config;
 }
Beispiel #15
0
        public EngineService(IActionService actionService, IEngineConfiguration engineConfiguration)
        {
            _actionService = actionService;

            _engineConfiguration = engineConfiguration;

            _runtime = WorkflowRuntimeFactory();
        }
Beispiel #16
0
 public MailConfiguration(IEngineConfiguration engineConfiguration, string integrationPointName)
     : this()
 {
     var config = engineConfiguration.IntegrationPoints.Mail.Single(x => x.IntegrationPointName == integrationPointName);
     IntegrationPointName = integrationPointName;
     HostName = config.HostName;
     Port = config.Port;
 }
Beispiel #17
0
        public void Ensure_Passed_Configuration_Is_Applided_OnEmbedded()
        {
            IEngineConfiguration configuration = EngineConfiguration.Default;

            var engine = EngineFactory.CreateEmbedded(typeof(TestViewModel), configuration);

            Assert.Same(configuration, engine.Configuration);
        }
 public EngineConfigurationProviderLoaderContext(
     IEngineConfiguration configuration,
     IEngineConfigurationProvider configurationProvider,
     IEngineConventionProvider conventionProvider)
 {
     this.Configuration = configuration;
     this.ConfigurationProvider = configurationProvider;
     this.ConventionProvider = conventionProvider;
 }
 public EngineConfigurationProviderLoaderContext(
     IEngineConfiguration configuration,
     IEngineConfigurationProvider configurationProvider,
     IEngineConventionProvider conventionProvider)
 {
     this.Configuration         = configuration;
     this.ConfigurationProvider = configurationProvider;
     this.ConventionProvider    = conventionProvider;
 }
        public void AddSimpleUser()
        {
            this.Builder.Include<SimpleUser>()
                .Setup(x => x.EmailAddress).Default()
                .Setup(x => x.FirstName).Default()
                .Setup(x => x.LastName).Default();

            Configuration = new EngineConfigurationFactory().Create(this.Builder, this.Builder.ConventionProvider);
        }
        public void AddSimpleUser()
        {
            this.Builder.Include <SimpleUser>()
            .Setup(x => x.EmailAddress).Default()
            .Setup(x => x.FirstName).Default()
            .Setup(x => x.LastName).Default();

            Configuration = new EngineConfigurationFactory().Create(this.Builder, this.Builder.ConventionProvider);
        }
        public MailConfiguration(IEngineConfiguration engineConfiguration, string integrationPointName)
            : this()
        {
            var config = engineConfiguration.IntegrationPoints.Mail.Single(x => x.IntegrationPointName == integrationPointName);

            IntegrationPointName = integrationPointName;
            HostName             = config.HostName;
            Port = config.Port;
        }
Beispiel #23
0
        public MainWindowViewModel(IEngineConfiguration aEngineConfiguration)
        {
            var xEngine = new FullEngine(aEngineConfiguration);

            xEngine.SetOutputHandler(
                new OutputHandler(
                    m => TestRunnerLog += m + Environment.NewLine));

            new Thread(() => xEngine.Execute()).Start();
        }
Beispiel #24
0
 /// <summary>
 /// Create converter
 /// </summary>
 /// <param name="logger"></param>
 /// <param name="serializer"></param>
 /// <param name="config"></param>
 /// <param name="cryptoProvider"></param>
 /// <param name="identity"></param>
 public PublishedNodesJobConverter(ILogger logger,
                                   IJsonSerializer serializer, IIdentity identity,
                                   IEngineConfiguration config = null, ISecureElement cryptoProvider = null)
 {
     _config         = config;
     _cryptoProvider = cryptoProvider;
     _serializer     = serializer ?? throw new ArgumentNullException(nameof(logger));
     _logger         = logger ?? throw new ArgumentNullException(nameof(logger));
     _identity       = identity ?? throw new ArgumentNullException(nameof(identity));
 }
 public JsonServiceConfiguration(IEngineConfiguration engineConfiguration, string integrationPointName)
     : this()
 {
     var config = engineConfiguration.IntegrationPoints.JsonService.Single(x => x.IntegrationPointName == integrationPointName);
     IntegrationPointName = integrationPointName;
     BaseUri = config.BaseUri;
     UserName = config.UserName;
     Password = config.Password;
     AlwaysSendBasicAuthHeader = config.AlwaysSendBasicAuthHeader;
 }
 /// <summary>
 /// Create instance of MonitoredItemMessageEncoder.
 /// </summary>
 /// <param name="logger"> Logger to be used for reporting. </param>
 /// <param name="standaloneConfig"> injected configuration. </param>
 /// <param name="engineConfig"> injected configuration. </param>
 public MonitoredItemMessageEncoder(ILogger logger,
                                    IStandaloneCliModelProvider standaloneConfig,
                                    IEngineConfiguration engineConfig)
 {
     _logger          = logger;
     _jsonContentType = standaloneConfig.StandaloneCliModel.LegacyCompatibility
         ? ContentMimeType.UaLegacyPublisher
         : ContentMimeType.Json;
     _enableRoutingInfo = engineConfig.EnableRoutingInfo.GetValueOrDefault(false);
 }
 public ElasticsearchConfiguration(IEngineConfiguration engineConfiguration, string integrationPointName)
     : this()
 {
     var config = engineConfiguration.IntegrationPoints.Elasticsearch.Single(x => x.IntegrationPointName == integrationPointName);
     IntegrationPointName = integrationPointName;
     Protocol = config.Protocol;
     HostName = config.HostName;
     Port = config.Port;
     DefaultIndex = config.DefaultIndex;
 }
        public void Setup()
        {
            this.Builder.Conventions(x =>
            {
                x.Register <TestTypeConvention>();
            });
            this.Builder.Include <TestTypeClass>();

            mConfiguration = new EngineConfigurationFactory().Create(this.Builder, this.Builder.ConventionProvider);
            mType          = mConfiguration.GetRegisteredType(typeof(TestTypeClass));
        }
        public JsonServiceConfiguration(IEngineConfiguration engineConfiguration, string integrationPointName)
            : this()
        {
            var config = engineConfiguration.IntegrationPoints.JsonService.Single(x => x.IntegrationPointName == integrationPointName);

            IntegrationPointName = integrationPointName;
            BaseUri  = config.BaseUri;
            UserName = config.UserName;
            Password = config.Password;
            AlwaysSendBasicAuthHeader = config.AlwaysSendBasicAuthHeader;
        }
 /// <summary>
 /// Initialises a new instance of <see cref="RazorEngineHost" />
 /// </summary>
 /// <param name="config">The template service configuration.</param>
 internal RazorEngineHost(IEngineConfiguration config)
 {
     if (config == null)
     {
         throw new ArgumentNullException(nameof(config));
     }
     //if (config.Debug && config.DisableTempFileLocking)
     //    throw new InvalidOperationException("Debug && DisableTempFileLocking is not supported, you need to disable one of them. When Roslyn has been released and you are seeing this, open an issue as this might be possible now.");
     this.Configuration = config;
     this.Core          = new RazorEngineCore(new ReadOnlyEngineConfiguration(config));
 }
Beispiel #31
0
        private static Tuple <IEngineCore, IPageLookup> CreateDefaultDependencies(
            ITemplateManager manager,
            IEngineConfiguration configuration)
        {
            IEngineCore core = new EngineCore(manager, configuration);

            IPageFactoryProvider pageFactory = new DefaultPageFactory(core.KeyCompile);
            IPageLookup          lookup      = new DefaultPageLookup(pageFactory);

            return(new Tuple <IEngineCore, IPageLookup>(core, lookup));
        }
Beispiel #32
0
 public Engine(IEngineConfiguration configuration)
 {
     _configuration = configuration;
     foreach (string plugin in _plugins)
     {
         Bass.PluginLoad(plugin);
     }
     _eq       = new PeakEQParameters();
     _eqHandle = GCHandle.Alloc(_eq, GCHandleType.Pinned);
     _maxfft   = (int)(DataFlags.Available | DataFlags.FFT2048);
 }
        public void Setup()
        {
            this.Builder.Conventions(x =>
            {
                x.Register<TestTypeConvention>();
            });
            this.Builder.Include<TestTypeClass>();

            mConfiguration = new EngineConfigurationFactory().Create(this.Builder, this.Builder.ConventionProvider);
            mType = mConfiguration.GetRegisteredType(typeof(TestTypeClass));
        }
Beispiel #34
0
        public ElasticsearchConfiguration(IEngineConfiguration engineConfiguration, string integrationPointName)
            : this()
        {
            var config = engineConfiguration.IntegrationPoints.Elasticsearch.Single(x => x.IntegrationPointName == integrationPointName);

            IntegrationPointName = integrationPointName;
            Protocol             = config.Protocol;
            HostName             = config.HostName;
            Port         = config.Port;
            DefaultIndex = config.DefaultIndex;
        }
 public RabbitMQConfiguration(IEngineConfiguration engineConfiguration, string integrationPointName)
     : this()
 {
     var config = engineConfiguration.IntegrationPoints.RabbitMQ.Single(x => x.IntegrationPointName == integrationPointName);
     IntegrationPointName = integrationPointName;
     QueueName = config.QueueName;
     ExchangeName = config.ExchangeName;
     UserName = config.UserName;
     Password = config.Password;
     HostName = config.HostName;
     VirtualHost = config.VirtualHost;
 }
Beispiel #36
0
        /// <summary>
        /// Creates <see cref="EngineCore" /> with specified <seealso cref="EngineConfiguration"/>/>
        /// </summary>
        /// <param name="templateManager">Template manager</param>
        /// <param name="configuration">Engine configuration options</param>
        public EngineCore(
            ITemplateManager templateManager,
            IEngineConfiguration configuration)
        {
            if (configuration == null)
            {
                throw new ArgumentNullException(nameof(configuration));
            }

            this.TemplateManager = templateManager;
            this.Configuration   = configuration;
        }
        public void Create_WithEmptySetup_ReturnsConfiguration()
        {
            var configurationProviderMock = new Mock <IEngineConfigurationProvider>();
            var conventionProviderMock    = new Mock <IEngineConventionProvider>();
            var factory = new EngineConfigurationFactory();

            IEngineConfiguration configuration = factory.Create(
                configurationProviderMock.Object,
                conventionProviderMock.Object);

            Assert.NotNull(configuration);
        }
Beispiel #38
0
        public RabbitMQConfiguration(IEngineConfiguration engineConfiguration, string integrationPointName)
            : this()
        {
            var config = engineConfiguration.IntegrationPoints.RabbitMQ.Single(x => x.IntegrationPointName == integrationPointName);

            IntegrationPointName = integrationPointName;
            QueueName            = config.QueueName;
            ExchangeName         = config.ExchangeName;
            UserName             = config.UserName;
            Password             = config.Password;
            HostName             = config.HostName;
            VirtualHost          = config.VirtualHost;
        }
Beispiel #39
0
 /// <summary>
 /// Create converter
 /// </summary>
 /// <param name="logger"></param>
 /// <param name="serializer"></param>
 /// <param name="engineConfig"></param>
 /// <param name="clientConfig"></param>
 /// <param name="cryptoProvider"></param>
 public PublishedNodesJobConverter(
     ILogger logger,
     IJsonSerializer serializer,
     IEngineConfiguration engineConfig,
     IClientServicesConfig clientConfig,
     ISecureElement cryptoProvider = null)
 {
     _engineConfig   = engineConfig ?? throw new ArgumentNullException(nameof(engineConfig));
     _clientConfig   = clientConfig ?? throw new ArgumentNullException(nameof(clientConfig));
     _cryptoProvider = cryptoProvider;
     _serializer     = serializer ?? throw new ArgumentNullException(nameof(serializer));
     _logger         = logger ?? throw new ArgumentNullException(nameof(logger));
 }
Beispiel #40
0
        public MainWindowViewModel(IEngineConfiguration aEngineConfiguration)
        {
            var xEngine = new Engine(aEngineConfiguration)
            {
                OutputHandler = new OutputHandler(
                    m =>
                {
                    TestRunnerLog += m + Environment.NewLine;
                    OnPropertyChanged(nameof(TestRunnerLog));
                })
            };

            new Thread(() => xEngine.Execute()).Start();
        }
        public void Setup()
        {
            this.Builder.Conventions(x =>
            {
                x.Register<TestPropertyConvention>();
            });
            this.Builder.Include<TestPropertyClass>()
                .Setup(x => x.Test).Default()
                .Setup(x => x.TestIgnore);

            mConfiguration = new EngineConfigurationFactory().Create(this.Builder, this.Builder.ConventionProvider);
            mType = mConfiguration.GetRegisteredType(typeof(TestPropertyClass));
            mTestProperty = mType.GetRegisteredMembers().Where(x => x.Member.Name == "Test").Single();
            mTestIgnoreProperty = mType.GetRegisteredMembers().Where(x => x.Member.Name == "TestIgnore").Single();
        }
 public CascadeBaseTypeConfigurationAction(IEngineConfiguration configuration)
 {
     mConfiguration = configuration;
 }
 public GenerationSessionFactory(IEngineConfiguration config, IEngineConventionProvider conventionProvider)
 {
     mConfig = config;
     mConventionProvider = conventionProvider;
 }
Beispiel #44
0
 public Engine(IEngineConfiguration configuration)
 {
     this.parser = configuration.Parser;
     this.urlBuilder = configuration.UrlBuilder;
     this.spider = configuration.Spider;
 }
 /// <summary>
 /// Initializes a new instance of the <see cref="FiddlerCoreEngine"/> class.
 /// </summary>
 /// <param name="engineConfiguration">The engine configuration.</param>
 public FiddlerCoreEngine(ILogger engineLogger, IEngineConfiguration engineConfiguration)
 {
     configuration = engineConfiguration;
     logger = engineLogger;
 }
 public TypeFieldConventionContext(IEngineConfiguration config, IEngineConfigurationTypeMember member)
     : base(config, member)
 {
 }
        protected virtual void TryRegisterType(IEngineConfiguration configuration, Type configType)
        {
            IEngineConfigurationType configuredType = configuration.GetRegisteredType(configType);
            if (configuredType == null)
            {
                configuration.RegisterType(configType);
                configuredType = configuration.GetRegisteredType(configType);
            }

            foreach (Type interfaceType in configType.GetInterfaces())
            {
                TryRegisterType(configuration, interfaceType);
            }

            Type baseType = configType.BaseType;
            if (baseType != null)
            {
                TryRegisterType(configuration, baseType);
            }
        }
 public ApplyTypeMemberConventionsAction(IEngineConfiguration configuration,
     IEngineConventionProvider conventions)
 {
     mConfiguration = configuration;
     mConventionProvider = conventions;
 }
        public void SetupObjects()
        {
            this.Builder.Include<SimpleMethodClass>()
                .Invoke(x=>x.SetSomething("Literal"))
                .Invoke(x=>x.SetSomething(
                    Use.Source<String, FirstNameSource>(),
                    Use.Source<String, LastNameSource>()));

            Configuration = new EngineConfigurationFactory().Create(this.Builder, this.Builder.ConventionProvider);

            // Get some info for the tests
            mEngineConfigurationType = Configuration.GetRegisteredType(typeof(SimpleMethodClass));
            mSingleArgMethod = (EngineTypeMethodMember)ReflectionHelper.GetMember(
                typeof(SimpleMethodClass).GetMethod("SetSomething", new Type[] { typeof(string) }));
            mDoubleArgMethod = (EngineTypeMethodMember)ReflectionHelper.GetMember(
                typeof(SimpleMethodClass).GetMethod("SetSomething", new Type[] { typeof(string), typeof(string) }));
        }