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));
}
