/// <summary> /// Initializes a new instance of the <see cref="Response"/> class. /// </summary> /// <param name="responseMessage"> /// The response. /// </param> private Response(ResponseMessage responseMessage) { ResponseMessage = responseMessage; _fileSystemHandler = new LocalFileSystemHandler(); _responseMessageTransformer = new ResponseMessageTransformer(_fileSystemHandler); }
/// <summary> /// Initializes a new instance of the <see cref="RespondWithAProvider"/> class. /// </summary> /// <param name="registrationCallback">The registration callback.</param> /// <param name="requestMatcher">The request matcher.</param> /// <param name="fileSystemHandler">The fileSystemHandler.</param> /// <param name="saveToFile">Optional boolean to indicate if this mapping should be saved as static mapping file.</param> public RespondWithAProvider(RegistrationCallback registrationCallback, IRequestMatcher requestMatcher, IFileSystemHandler fileSystemHandler, bool saveToFile = false) { _registrationCallback = registrationCallback; _requestMatcher = requestMatcher; _fileSystemHandler = fileSystemHandler; _saveToFile = saveToFile; }
public CollectionsStorageRepository( IJsonSerializer jsonSerializer, IFileSystemHandler fileSystemHandler) { this.jsonSerializer = jsonSerializer; this.fileSystemHandler = fileSystemHandler; }
public CachedFileStorage( IFileSystemHandler fileSystemHandler, IJsonSerializer jsonSerializer) { this.fileSystemHandler = fileSystemHandler; this.jsonSerializer = jsonSerializer; }
/// <summary> /// Run the server. The method will not return until Stop() is called. /// </summary> public void Run() { if (authHandler == null) { authHandler = new DefaultAuthHandler(); } if (fsHandler == null) { fsHandler = new DefaultFileSystemHandler(); } if (socket == null) { socket = new TcpListener(endpoint); } socket.Start(); // listen for new connections try { while (true) { Socket peer = socket.AcceptSocket(); IPEndPoint peerPort = (IPEndPoint)peer.RemoteEndPoint; Session session = new Session(peer, bufferSize, authHandler.Clone(peerPort), fsHandler.Clone(peerPort), logHandler.Clone(peerPort)); session.Start(); sessions.Add(session); // purge old sessions for (int i = sessions.Count - 1; i >= 0; --i) { if (!sessions[i].IsOpen) { sessions.RemoveAt(i); --i; } } } } catch (SocketException) { // ignore, Stop() will probably cause this exception } finally { // close all running connections foreach (Session s in sessions) { s.Stop(); } } }
public ScribanContextFactory(IFileSystemHandler fileSystemHandler, TransformerType transformerType) { Check.NotNull(fileSystemHandler, nameof(fileSystemHandler)); Check.Condition(transformerType, t => t == TransformerType.Scriban || t == TransformerType.ScribanDotLiquid, nameof(transformerType)); _fileSystemHandler = fileSystemHandler; _transformerType = transformerType; }
public CollectionsStorage( IJsonSerializer jsonSerializer, IFileSystemHandler fileSystemHandler, string fileName) { this.jsonSerializer = jsonSerializer; this.fileSystemHandler = fileSystemHandler; this.fileName = fileName; }
public WireMockService(string map, int port, bool useSsl, string assemblyFile, string typeName) { _port = port; _useSsl = useSsl; _fileHandler = new LocalFileSystemHandler(map); _assemblyFile = assemblyFile; _typeName = typeName; _logger = new WireMockConsoleLogger(); }
public void Initialize(IBuildMusicOptions options, IFileSystemHandler fileSystemHandler = null) { _FileSystemHandler = fileSystemHandler ?? new FileSystemHandler(); _IsInitializing = true; OptionPage = options; InitializeDuringBuildControls(); _IsInitializing = false; _ResourceManager = new ResourceManager(this.GetType()); }
public static void Register(IHandlebars handlebarsContext, IFileSystemHandler fileSystemHandler) { HandleBarsRegex.Register(handlebarsContext); HandleBarsJsonPath.Register(handlebarsContext); HandleBarsLinq.Register(handlebarsContext); HandleBarsRandom.Register(handlebarsContext); HandleBarsXeger.Register(handlebarsContext); HandleBarsFile.Register(handlebarsContext, fileSystemHandler); }
public static void Register(IHandlebars handlebarsContext, IFileSystemHandler fileSystemHandler) { handlebarsContext.RegisterHelper("File", (writer, context, arguments) => { string value = ParseArgumentAndReadFileFragment(handlebarsContext, context, fileSystemHandler, arguments); writer.Write(value); }); handlebarsContext.RegisterHelper("File", (writer, options, context, arguments) => { string value = ParseArgumentAndReadFileFragment(handlebarsContext, context, fileSystemHandler, arguments); options.Template(writer, value); }); }
/// <summary> /// Initializes a new instance of the <see cref="Mapping"/> class. /// </summary> /// <param name="guid">The unique identifier.</param> /// <param name="title">The unique title (can be null).</param> /// <param name="path">The full file path from this mapping title (can be null).</param> /// <param name="fileSystemHandler">The fileSystemHandler.</param> /// <param name="requestMatcher">The request matcher.</param> /// <param name="provider">The provider.</param> /// <param name="priority">The priority for this mapping.</param> /// <param name="scenario">The scenario. [Optional]</param> /// <param name="executionConditionState">State in which the current mapping can occur. [Optional]</param> /// <param name="nextState">The next state which will occur after the current mapping execution. [Optional]</param> public Mapping(Guid guid, [CanBeNull] string title, [CanBeNull] string path, [NotNull] IFileSystemHandler fileSystemHandler, [NotNull] IRequestMatcher requestMatcher, [NotNull] IResponseProvider provider, int priority, [CanBeNull] string scenario, [CanBeNull] string executionConditionState, [CanBeNull] string nextState) { Guid = guid; Title = title; Path = path; FileSystemHandler = fileSystemHandler; RequestMatcher = requestMatcher; Provider = provider; Priority = priority; Scenario = scenario; ExecutionConditionState = executionConditionState; NextState = nextState; }
/// <summary> /// Creates a new session, which can afterwards be started with Start(). /// </summary> public Session(Socket socket, int bufferSize, IAuthHandler authHandler, IFileSystemHandler fileSystemHandler, ILogHandler logHandler) { this.controlSocket = socket; this.dataBufferSize = bufferSize; this.authHandler = authHandler; this.fsHandler = fileSystemHandler; this.logHandler = logHandler; this.cmdRcvBuffer = new byte[CMD_BUFFER_SIZE]; this.cmdRcvBytes = 0; this.dataBuffer = new byte[dataBufferSize + 1]; // +1 for partial EOL this.randomTextIndex = new Random(); this.thread = new Thread(new ThreadStart(this.Work)); }
public static string ReadAllTextWithRetryAndDelay([NotNull] IFileSystemHandler filehandler, [NotNull] string path) { Check.NotNull(filehandler, nameof(filehandler)); Check.NotNullOrEmpty(path, nameof(path)); for (int i = 1; i <= NumberOfRetries; ++i) { try { return(filehandler.ReadMappingFile(path)); } catch { Thread.Sleep(DelayOnRetry); } } throw new IOException(); }
public static void Register(IHandlebars handlebarsContext, IFileSystemHandler fileSystemHandler) { // Register https://github.com/StefH/Handlebars.Net.Helpers HandlebarsHelpers.Register(handlebarsContext); // Register WireMock.Net specific helpers HandlebarsRegex.Register(handlebarsContext); HandlebarsJsonPath.Register(handlebarsContext); HandlebarsLinq.Register(handlebarsContext); HandlebarsRandom.Register(handlebarsContext); HandlebarsXeger.Register(handlebarsContext); HandlebarsXPath.Register(handlebarsContext); HandlebarsFile.Register(handlebarsContext, fileSystemHandler); }
public static void Register(IHandlebars handlebarsContext, IFileSystemHandler fileSystemHandler) { // Register https://github.com/StefH/Handlebars.Net.Helpers HandlebarsHelpers.Register(handlebarsContext, o => { o.CustomHelperPaths = new string[] { Directory.GetCurrentDirectory() #if !NETSTANDARD1_3 , Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location) #endif } .Distinct() .ToList(); o.CustomHelpers = new Dictionary <string, IHelpers> { { "File", new FileHelpers(handlebarsContext, fileSystemHandler) } }; }); }
public static bool TryReadMappingFileWithRetryAndDelay([NotNull] IFileSystemHandler handler, [NotNull] string path, out string value) { Check.NotNull(handler, nameof(handler)); Check.NotNullOrEmpty(path, nameof(path)); value = null; for (int i = 1; i <= NumberOfRetries; ++i) { try { value = handler.ReadMappingFile(path); return(true); } catch { Thread.Sleep(DelayOnRetry); } } return(false); }
private FluentMockServer(IFluentMockServerSettings settings) { settings.Logger = settings.Logger ?? new WireMockConsoleLogger(); _logger = settings.Logger; _fileSystemHandler = settings.FileSystemHandler ?? new LocalFileSystemHandler(); _logger.Info("WireMock.Net by Stef Heyenrath (https://github.com/WireMock-Net/WireMock.Net)"); _logger.Debug("WireMock.Net server settings {0}", JsonConvert.SerializeObject(settings, Formatting.Indented)); if (settings.Urls != null) { Urls = settings.Urls.ToArray(); } else { int port = settings.Port > 0 ? settings.Port.Value : PortUtils.FindFreeTcpPort(); Urls = new[] { $"{(settings.UseSSL == true ? "https" : "http")}://localhost:{port}" }; } _options.PreWireMockMiddlewareInit = settings.PreWireMockMiddlewareInit; _options.PostWireMockMiddlewareInit = settings.PostWireMockMiddlewareInit; _options.Logger = _logger; #if USE_ASPNETCORE _httpServer = new AspNetCoreSelfHost(_options, Urls); #else _httpServer = new OwinSelfHost(_options, Urls); #endif Ports = _httpServer.Ports; var startTask = _httpServer.StartAsync(); using (var ctsStartTimeout = new CancellationTokenSource(settings.StartTimeout)) { while (!_httpServer.IsStarted) { // Throw exception if service start fails if (_httpServer.RunningException != null) { throw new WireMockException($"Service start failed with error: {_httpServer.RunningException.Message}", _httpServer.RunningException); } if (ctsStartTimeout.IsCancellationRequested) { // In case of an aggregate exception, throw the exception. if (startTask.Exception != null) { throw new WireMockException($"Service start failed with error: {startTask.Exception.Message}", startTask.Exception); } // Else throw TimeoutException throw new TimeoutException($"Service start timed out after {TimeSpan.FromMilliseconds(settings.StartTimeout)}"); } ctsStartTimeout.Token.WaitHandle.WaitOne(ServerStartDelayInMs); } } if (settings.AllowPartialMapping == true) { AllowPartialMapping(); } if (settings.StartAdminInterface == true) { if (!string.IsNullOrEmpty(settings.AdminUsername) && !string.IsNullOrEmpty(settings.AdminPassword)) { SetBasicAuthentication(settings.AdminUsername, settings.AdminPassword); } InitAdmin(); } if (settings.ReadStaticMappings == true) { ReadStaticMappings(); } if (settings.WatchStaticMappings == true) { WatchStaticMappings(); } if (settings.ProxyAndRecordSettings != null) { InitProxyAndRecord(settings); } if (settings.RequestLogExpirationDuration != null) { SetRequestLogExpirationDuration(settings.RequestLogExpirationDuration); } if (settings.MaxRequestLogCount != null) { SetMaxRequestLogCount(settings.MaxRequestLogCount); } }
internal Data(IFileSystemHandler fileSystemHandler = null) { this.FileSystemHandler = fileSystemHandler ?? new FileSystemHandler(); }
private static string ParseArgumentAndReadFileFragment(IHandlebars handlebarsContext, dynamic context, IFileSystemHandler fileSystemHandler, object[] arguments) { Check.Condition(arguments, args => args.Length == 1, nameof(arguments)); Check.NotNull(arguments[0], "arguments[0]"); switch (arguments[0]) { case string path: var templateFunc = handlebarsContext.Compile(path); string transformed = templateFunc(context); return(fileSystemHandler.ReadResponseBodyAsString(transformed)); } throw new NotSupportedException($"The value '{arguments[0]}' with type '{arguments[0]?.GetType()}' cannot be used in Handlebars File."); }
public ScribanContext(IFileSystemHandler fileSystemHandler, TransformerType transformerType) { FileSystemHandler = fileSystemHandler ?? throw new ArgumentNullException(nameof(fileSystemHandler)); _transformerType = transformerType; }
/// <summary> /// Run the server. The method will not return until Stop() is called. /// </summary> public void Run() { if (authHandler == null) authHandler = new DefaultAuthHandler(); if (fsHandler == null) fsHandler = new DefaultFileSystemHandler(); if (socket == null) socket = new TcpListener(endpoint); socket.Start(); // listen for new connections try { while (true) { Socket peer = socket.AcceptSocket(); IPEndPoint peerPort = (IPEndPoint) peer.RemoteEndPoint; Session session = new Session(peer, bufferSize, authHandler.Clone(peerPort), fsHandler.Clone(peerPort), logHandler.Clone(peerPort)); session.Start(); sessions.Add(session); // purge old sessions for (int i = sessions.Count - 1; i >= 0; --i) { if (!sessions[i].IsOpen) { sessions.RemoveAt(i); --i; } } } } catch (SocketException) { // ignore, Stop() will probably cause this exception } finally { // close all running connections foreach (Session s in sessions) { s.Stop(); } } }
public Task <ResponseMessage> ProvideResponseAsync(RequestMessage requestMessage, IFileSystemHandler fileSystemHandler) { return(_responseMessageFunc(requestMessage, _settings)); }
public ResponseMessageTransformer([NotNull] IFileSystemHandler fileSystemHandler) { Check.NotNull(fileSystemHandler, nameof(fileSystemHandler)); HandlebarsHelpers.Register(HandlebarsContext, fileSystemHandler); }
private ExplorerTree.Data.API.Data CreateData(IFileSystemHandler fileSystemHandler = null) { fileSystemHandler = fileSystemHandler ?? Substitute.For <IFileSystemHandler>(); return(new ExplorerTree.Data.API.Data(fileSystemHandler)); }
public ProjectFactory(IFileSystemHandler fileSystemHandler) { this.fileSystemHandler = fileSystemHandler; }
public HandlebarsContextFactory(IFileSystemHandler fileSystemHandler, Action <IHandlebars, IFileSystemHandler> action) { _fileSystemHandler = fileSystemHandler; _action = action; }
public async Task <ResponseMessage> ProvideResponseAsync(RequestMessage requestMessage, IFileSystemHandler fileSystemHandler) { Check.NotNull(requestMessage, nameof(requestMessage)); if (Delay != null) { await Task.Delay(Delay.Value); } if (Callback != null) { var callbackResponseMessage = Callback(requestMessage); if (!WithCallbackUsed) { // Copy StatusCode from ResponseMessage callbackResponseMessage.StatusCode = ResponseMessage.StatusCode; // Copy Headers from ResponseMessage (if defined) if (ResponseMessage.Headers != null) { callbackResponseMessage.Headers = ResponseMessage.Headers; } } return(callbackResponseMessage); } if (ProxyUrl != null && _httpClientForProxy != null) { var requestUri = new Uri(requestMessage.Url); var proxyUri = new Uri(ProxyUrl); var proxyUriWithRequestPathAndQuery = new Uri(proxyUri, requestUri.PathAndQuery); return(await HttpClientHelper.SendAsync(_httpClientForProxy, requestMessage, proxyUriWithRequestPathAndQuery.AbsoluteUri)); } if (UseTransformer) { var responseMessageTransformer = new ResponseMessageTransformer(fileSystemHandler); return(responseMessageTransformer.Transform(requestMessage, ResponseMessage)); } if (!UseTransformer && ResponseMessage.BodyData?.BodyAsFileIsCached == true) { ResponseMessage.BodyData.BodyAsBytes = fileSystemHandler.ReadResponseBodyAsFile(ResponseMessage.BodyData.BodyAsFile); ResponseMessage.BodyData.BodyAsFile = null; } return(ResponseMessage); }
public Task <ResponseMessage> ProvideResponseAsync(RequestMessage requestMessage, IFileSystemHandler fileSystemHandler) { return(Task.FromResult(_responseMessageFunc(requestMessage))); }
/// <summary> /// Constructor /// </summary> /// <param name="fileSystemHandler">The IFileSystemHandler.</param> public OwinResponseMapper(IFileSystemHandler fileSystemHandler) { Check.NotNull(fileSystemHandler, nameof(fileSystemHandler)); _fileSystemHandler = fileSystemHandler; }
public HandlebarsContextFactory([NotNull] IFileSystemHandler fileSystemHandler, [CanBeNull] Action <IHandlebars, IFileSystemHandler> action) { _fileSystemHandler = fileSystemHandler ?? throw new ArgumentNullException(nameof(fileSystemHandler)); _action = action; }