private string GetCheckedIn(RequestHandlerBase handler) { string href = handler.GetLocalPath("/!svn/ver/" + item.Revision + "/" + Helper.Encode(item.Name, true)); return ("<lp1:checked-in><D:href>" + Helper.UrlEncodeIfNeccesary(href) + "</D:href></lp1:checked-in>"); }
public virtual void Request(RequestHandlerBase handler) { if (!enabled) { return; } performanceCounters[handler.GetType()].Increment(); }
public string Href(RequestHandlerBase handler) { if (label == null) { return(handler.GetLocalPath(path)); } else { return(handler.GetLocalPath("/!svn/bln/" + label)); } }
private string GetContentLength(RequestHandlerBase handler) { if (handler is SAWSPropFindHandler) { SAWSPropFindHandler h = (SAWSPropFindHandler)handler; return("<lp1:getcontentlength>" + h.GetSDKObject().GetFileSize(item.Name) + "</lp1:getcontentlength>"); } else { return("<lp1:getcontentlength>" + sourceControlProvider.ReadFile(item).Length + "</lp1:getcontentlength>"); } }
public string GetProperty(RequestHandlerBase handler, XmlElement property) { switch (property.LocalName) { case "baseline-collection": return(GetBaselineCollection(handler)); case "version-name": return(GetVersionName(property)); default: throw new Exception("Property not found: " + property.LocalName); } }
public string Href(RequestHandlerBase handler) { string href = item.Name; if (!href.StartsWith("/")) { href = "/" + href; } if (item.ItemType == ItemType.Folder && !href.EndsWith("/")) { href += "/"; } return(handler.GetLocalPath(Helper.Encode(href))); }
public string Href(RequestHandlerBase handler) { string path = item.Name; if (!path.StartsWith("/")) { path = "/" + path; } string href = "/!svn/bc/" + requestVersion + path; if (item.ItemType == ItemType.Folder && ((href.Length == 0) || (href[href.Length - 1] != '/'))) { href += "/"; } return(handler.GetLocalPath(Helper.Encode(href))); }
public string GetProperty(RequestHandlerBase handler, XmlElement property) { switch (property.LocalName) { case "version-controlled-configuration": return(GetVersionControlledConfiguration(handler)); case "resourcetype": return(GetResourceType()); case "baseline-relative-path": return(GetBaselineRelativePath()); case "repository-uuid": return(GetRepositoryUUID()); case "checked-in": return(GetCheckedIn(handler)); case "deadprop-count": return(GetDeadPropCount()); case "creator-displayname": return(GetCreatorDisplayName()); case "creationdate": return(GetCreationDate()); case "version-name": return(GetVersionName()); case "getcontentlength": return(GetContentLength(handler)); case "lockdiscovery": return(GetLockDiscovery()); case "md5-checksum": return(GetMd5Checksum(handler)); default: throw new Exception("Property not found: " + property.LocalName); } }
private string GetMd5Checksum(RequestHandlerBase handler) { if (handler is SAWSHandlerBase) { SAWSHandlerBase sawshandler = handler as SAWSHandlerBase; return ("<lp2:md5-checksum>" + Helper.GetMd5Checksum(sawshandler.ReadFile(item.Name, item.Revision)) + "</lp2:md5-checksum>"); } else if (sourceControlProvider != null) { return("<lp2:md5-checksum>" + Helper.GetMd5Checksum(sourceControlProvider.ReadFile(item)) + "</lp2:md5-checksum>"); } else { // it's not possible reaching here. return("<lp2:md5-checksum></lp2:md5-checksum>"); // invalid .. } }
private string GetCheckedIn(RequestHandlerBase handler) { // int maxVersion = sourceControlProvider.GetLatestVersion(); int maxVersion; if (sourceControlProvider != null) { maxVersion = sourceControlProvider.GetLatestVersion(); } else { const string latestVersion = "Repository.Latest.Version"; if (RequestCache.Items[latestVersion] == null) { maxVersion = nLatestVer; } else { maxVersion = (int)RequestCache.Items[latestVersion]; } } return("<lp1:checked-in><D:href>" + handler.GetLocalPath("/!svn/bln/" + maxVersion) + "</D:href></lp1:checked-in>"); }
private static string GetVersionControlledConfiguration(RequestHandlerBase handler) { return ("<lp1:version-controlled-configuration><D:href>" + handler.VccPath + "</D:href></lp1:version-controlled-configuration>"); }
public UpdateReportService(RequestHandlerBase handler, TFSSourceControlProvider sourceControlProvider) { this.handler = handler; this.sourceControlProvider = sourceControlProvider; }
public ServiceDispatcher(IContainer container, List <Type> serviceTypes, ClusterConnection clusterConnection) { _clusterConnection = clusterConnection; foreach (Type serviceType in serviceTypes) { var serviceTypeCapture = serviceType; var serviceInstance = new Lazy <object>(() => container.Resolve(serviceTypeCapture)); foreach (MethodInfo serviceMethod in serviceType.GetMethods()) { if (serviceMethod.IsStatic || !serviceMethod.IsPublic) { continue; } var newHandler = RequestHandlerBase.CreateFromMethod(serviceInstance, serviceMethod); if (newHandler != null) { Type requestMessageType = newHandler.RequestMessageType; int requestMessageId; if (!_messageMap.ContainsType(requestMessageType)) { requestMessageId = _nextMessageId++; _messageMap.Add(requestMessageType, requestMessageId); } else { requestMessageId = _messageMap.GetMessageIdByType(requestMessageType); } if (_messageHandlersById.TryGetValue(requestMessageId, out IRequestHanlder existingHandler)) { _messageHandlersById[requestMessageId] = new LinkedRequestHandler(newHandler, existingHandler); } else { _messageHandlersById.Add(requestMessageId, newHandler); } Type?responseMessageType = newHandler.ResponseMessageType; if (responseMessageType != null) { if (!_messageMap.ContainsType(responseMessageType)) { int responseMessageId = _nextMessageId++; _messageMap.Add(responseMessageType, responseMessageId); _requestResponseMessageMap[requestMessageId] = responseMessageId; } else { _requestResponseMessageMap[requestMessageId] = _messageMap.GetMessageIdByType(responseMessageType); } } else { _requestResponseMessageMap[requestMessageId] = -1; } } } } }
private string GetBaselineCollection(RequestHandlerBase handler) { return("<lp1:baseline-collection><D:href>" + handler.GetLocalPath("/!svn/bc/" + label) + "/</D:href></lp1:baseline-collection>"); }
public string GetProperty(RequestHandlerBase handler, XmlElement property) { return(node.GetProperty(handler, property)); }
void OnEnable() { handler = (RequestHandlerBase)target; }
private static void Main() { Application.EnableVisualStyles(); Application.SetCompatibleTextRenderingDefault(false); Cef.EnableHighDPISupport(); WindowRestoreMessage = NativeMethods.RegisterWindowMessage("TweetDuckRestore"); if (!FileUtils.CheckFolderWritePermission(StoragePath)) { FormMessage.Warning("Permission Error", "TweetDuck does not have write permissions to the storage folder: " + StoragePath, FormMessage.OK); return; } if (Arguments.HasFlag(Arguments.ArgRestart)) { LockManager.Result lockResult = LockManager.LockWait(10000); while (lockResult != LockManager.Result.Success) { if (lockResult == LockManager.Result.Fail) { FormMessage.Error("TweetDuck Has Failed :(", "An unknown error occurred accessing the data folder. Please, make sure TweetDuck is not already running. If the problem persists, try restarting your system.", FormMessage.OK); return; } else if (!FormMessage.Warning("TweetDuck Cannot Restart", "TweetDuck is taking too long to close.", FormMessage.Retry, FormMessage.Exit)) { return; } lockResult = LockManager.LockWait(5000); } } else { LockManager.Result lockResult = LockManager.Lock(); if (lockResult == LockManager.Result.HasProcess) { if (!LockManager.RestoreLockingProcess() && FormMessage.Error("TweetDuck is Already Running", "Another instance of TweetDuck is already running.\nDo you want to close it?", FormMessage.Yes, FormMessage.No)) { if (!LockManager.CloseLockingProcess()) { FormMessage.Error("TweetDuck Has Failed :(", "Could not close the other process.", FormMessage.OK); return; } lockResult = LockManager.Lock(); } else { return; } } if (lockResult != LockManager.Result.Success) { FormMessage.Error("TweetDuck Has Failed :(", "An unknown error occurred accessing the data folder. Please, make sure TweetDuck is not already running. If the problem persists, try restarting your system.", FormMessage.OK); return; } } Config.LoadAll(); if (Arguments.HasFlag(Arguments.ArgImportCookies)) { ProfileManager.ImportCookies(); } else if (Arguments.HasFlag(Arguments.ArgDeleteCookies)) { ProfileManager.DeleteCookies(); } if (Arguments.HasFlag(Arguments.ArgUpdated)) { WindowsUtils.TryDeleteFolderWhenAble(InstallerPath, 8000); BrowserCache.TryClearNow(); } try{ RequestHandlerBase.LoadResourceRewriteRules(Arguments.GetValue(Arguments.ArgFreeze)); }catch (Exception e) { FormMessage.Error("Resource Freeze", "Error parsing resource rewrite rules: " + e.Message, FormMessage.OK); return; } BrowserCache.RefreshTimer(); CefSharpSettings.WcfEnabled = false; CefSharpSettings.LegacyJavascriptBindingEnabled = true; CefSettings settings = new CefSettings { UserAgent = BrowserUtils.UserAgentChrome, BrowserSubprocessPath = BrandName + ".Browser.exe", CachePath = StoragePath, UserDataPath = CefDataPath, LogFile = ConsoleLogFilePath, #if !DEBUG LogSeverity = Arguments.HasFlag(Arguments.ArgLogging) ? LogSeverity.Info : LogSeverity.Disable #endif }; CommandLineArgs.ReadCefArguments(Config.User.CustomCefArgs).ToDictionary(settings.CefCommandLineArgs); BrowserUtils.SetupCefArgs(settings.CefCommandLineArgs); Cef.Initialize(settings, false, new BrowserProcessHandler()); Application.ApplicationExit += (sender, args) => ExitCleanup(); FormBrowser mainForm = new FormBrowser(); Resources.Initialize(mainForm); Application.Run(mainForm); if (mainForm.UpdateInstallerPath != null) { ExitCleanup(); // ProgramPath has a trailing backslash string updaterArgs = "/SP- /SILENT /FORCECLOSEAPPLICATIONS /UPDATEPATH=\"" + ProgramPath + "\" /RUNARGS=\"" + Arguments.GetCurrentForInstallerCmd() + "\"" + (IsPortable ? " /PORTABLE=1" : ""); bool runElevated = !IsPortable || !FileUtils.CheckFolderWritePermission(ProgramPath); if (WindowsUtils.OpenAssociatedProgram(mainForm.UpdateInstallerPath, updaterArgs, runElevated)) { Application.Exit(); } else { RestartWithArgsInternal(Arguments.GetCurrentClean()); } } }
public override void SetUp() { base.SetUp(); httpContextAccessor = new Mock <IHttpContextAccessor>(); var httpContext = new Mock <HttpContext>(); serviceContext = new Mock <IServiceContext>(); objectService = new Mock <IObjectService>(); request = new Mock <HttpRequest>(); response = new Mock <HttpResponse>(); featureCollection = new Mock <IFeatureCollection>(); httpResponseFeature = new Mock <IHttpResponseFeature>(); requestHeaders = new HeaderDictionary(); responseHeaders = new HeaderDictionary(); requestQueryString = new QueryString(); requestQuery = new QueryCollection(); serializer = new JsonSerializerAdapter(); serviceContext.Setup(sc => sc.ObjectService).Returns(objectService.Object); config = BuildRoutine.ServiceConfig().FromBasic(); serviceContext.Setup(sc => sc.ServiceConfiguration).Returns(config); objectService.Setup(os => os.ApplicationModel).Returns(() => GetApplicationModel()); objectService.Setup(os => os.Get(It.IsAny <ReferenceData>())).Returns((ReferenceData referenceData) => { if (referenceData.Id == null) { referenceData = new ReferenceData { Id = "instance", ModelId = referenceData.ModelId, ViewModelId = referenceData.ViewModelId }; } return(objectDictionary[referenceData]); }); request.Setup(r => r.Headers).Returns(requestHeaders); request.Setup(r => r.QueryString).Returns(requestQueryString); request.Setup(r => r.Query).Returns(requestQuery); request.Setup(r => r.Method).Returns("POST"); request.Setup(r => r.Body).Returns(new MemoryStream()).Verifiable(); // https://stackoverflow.com/questions/34677203/testing-the-result-of-httpresponse-statuscode/34677864#34677864 response.SetupAllProperties(); response.Setup(r => r.Body).Returns(new MemoryStream()).Verifiable(); response.Setup(r => r.Headers).Returns(responseHeaders); httpContextAccessor.Setup(hca => hca.HttpContext).Returns(httpContext.Object); httpContextAccessor.Setup(hca => hca.HttpContext.Request).Returns(request.Object); httpContextAccessor.Setup(hca => hca.HttpContext.Response).Returns(response.Object); httpContextAccessor.Setup(hca => hca.HttpContext.Features).Returns(featureCollection.Object); httpContextAccessor.Setup(hca => hca.HttpContext.Response.HttpContext.Features.Get <IHttpResponseFeature>()).Returns(httpResponseFeature.Object); httpContextAccessor.Setup(hca => hca.HttpContext.Items).Returns(new Dictionary <object, object>()); RequestHandlerBase.ClearModelIndex(); testing = new HandleRequestHandler(serviceContext.Object, serializer, httpContextAccessor.Object, actionFactory: resolution => resolution.HasOperation ? new DoRequestHandler(serviceContext.Object, serializer, httpContextAccessor.Object, resolution) : new GetRequestHandler(serviceContext.Object, serializer, httpContextAccessor.Object, resolution) ); }
public void Dispatch(IHttpContext connection) { RequestHandlerBase handler = null; try { IHttpRequest request = connection.Request; if ("/!stats/request".Equals(request.LocalPath, StringComparison.InvariantCultureIgnoreCase)) { new StatsRenderer(Container.Resolve <ActionTrackingViaPerfCounter>()).Render(connection); return; } NetworkCredential credential = GetCredential(connection); string tfsUrl = parser.GetServerUrl(request, credential); if (string.IsNullOrEmpty(tfsUrl)) { SendFileNotFoundResponse(connection); return; } if (credential != null && (tfsUrl.ToLowerInvariant().EndsWith("codeplex.com") || tfsUrl.ToLowerInvariant().Contains("tfs.codeplex.com"))) { string username = credential.UserName; string domain = credential.Domain; if (!username.ToLowerInvariant().EndsWith("_cp")) { username += "_cp"; } if (domain == "") { domain = "snd"; } credential = new NetworkCredential(username, credential.Password, domain); } RequestCache.Items["serverUrl"] = tfsUrl; RequestCache.Items["projectName"] = parser.GetProjectName(request); RequestCache.Items["credentials"] = credential; handler = GetHandler(connection.Request.HttpMethod); if (handler == null) { actionTracking.Error(); SendUnsupportedMethodResponse(connection); return; } try { actionTracking.Request(handler); handler.Handle(connection, parser, credential); } catch (TargetInvocationException e) { ExceptionHelper.PreserveStackTrace(e.InnerException); throw e.InnerException; } } catch (WebException ex) { actionTracking.Error(); HttpWebResponse response = ex.Response as HttpWebResponse; if (response != null && response.StatusCode == HttpStatusCode.Unauthorized) { SendUnauthorizedResponse(connection); } else { throw; } } catch (NetworkAccessDeniedException) { SendUnauthorizedResponse(connection); } catch (IOException) { // Error caused by client cancelling operation under IIS 6 if (Configuration.LogCancelErrors) { throw; } } catch (HttpException ex) { // Check if error caused by client cancelling operation under IIS 7 if (!ex.Message.StartsWith("An error occurred while communicating with the remote host.") && !ex.Message.StartsWith("The remote host closed the connection.")) { throw; } if (Configuration.LogCancelErrors) { throw; } } finally { if (handler != null) { handler.Cancel(); } } }
public string Href(RequestHandlerBase handler) { return(handler.GetLocalPath(path)); }