private async Task DeleteInDestination(HashSet<Tuple<string, string, string>> src,
HashSet<Tuple<string, string, string>> dst)
{
dst.ExceptWith(src);
int n = 0;
// group by table + partition
foreach (var batch1 in dst.GroupBy(x => x.Item1 + x.Item2))
{
CloudTable dstTable = _dstClient.GetTableReference(batch1.First().Item1);
if (_token.IsCancellationRequested)
return;
foreach (var batch2 in batch1.Batch(100))
{
if (_token.IsCancellationRequested)
return;
var op = new TableBatchOperation();
foreach (var tuple in batch2)
{
op.Delete(new TableEntity(tuple.Item2, tuple.Item3) {ETag = "*"});
}
await dstTable.ExecuteBatchAsync(op, _token);
n += Math.Min(op.Count, 100);
Console.WriteLine("deleted {0} rows", n);
}
}
}
public void ExecuteTasks(HashSet<EndRequestTask> tasks)
{
var tasksGroupedByType = tasks.GroupBy(task => task.GetType())
.ToDictionary(grouping => grouping.Key, grouping => grouping.ToHashSet());
foreach (var type in tasksGroupedByType.Keys.OrderByDescending(GetExecutionPriority))
{
if (OnRequestExecutionTypes.ContainsKey(type) && OnRequestExecutionTypes[type] != null)
{
var requestBase = _kernel.Get(OnRequestExecutionTypes[type]) as ExecuteEndRequestBase;
if (requestBase != null)
{
var data = tasksGroupedByType[type].Select(task => task.BaseData).ToHashSet();
requestBase.Execute(data);
continue;
}
}
CurrentRequestData.ErrorSignal.Raise(
new Exception(
string.Format(
"Could not process tasks of type {0}. Please create a valid executor for the type",
type.FullName)));
}
}
public static void SomeFunction()
{
Dictionary<int, int> dict = new Dictionary<int, int>();
dict.Add(4, 3);
Console.WriteLine(dict[4]);
Console.WriteLine(dict.ContainsKey(8));
dict.Remove(4);
foreach(int key in dict.Keys)
Console.WriteLine(key);
foreach(int val in dict.Values)
Console.WriteLine(val);
foreach(var kv in dict)
Console.WriteLine(kv.Key + " " + kv.Value);
var dict2 = dict.ToDictionary(o => o.Key, o => o.Value);
var vals = dict.Values;
HashSet<int> hash = new HashSet<int>();
hash.Add(999);
Console.WriteLine(hash.Contains(999));
hash.Remove(999);
Console.WriteLine(hash.Contains(999));
foreach(int hashItem in hash)
Console.WriteLine(hashItem);
var z = hash.Select(o => 3).ToArray();
var g = hash.GroupBy(o => o).Select(o => o.Count()).Min();
}
/// <summary>
/// Resolver context
/// </summary>
/// <param name="dependencyBehavior">behavior for non-target packages</param>
/// <param name="targetIds">packages to install or update</param>
/// <param name="requiredPackageIds">packages required in the solution</param>
/// <param name="packagesConfig">existing packages</param>
/// <param name="preferredVersions">preferred package versions or the installed version of a package</param>
/// <param name="availablePackages">all packages from the gather stage</param>
public PackageResolverContext(DependencyBehavior dependencyBehavior,
IEnumerable<string> targetIds,
IEnumerable<string> requiredPackageIds,
IEnumerable<Packaging.PackageReference> packagesConfig,
IEnumerable<PackageIdentity> preferredVersions,
IEnumerable<SourcePackageDependencyInfo> availablePackages)
{
if (targetIds == null)
{
throw new ArgumentNullException(nameof(targetIds));
}
if (requiredPackageIds == null)
{
throw new ArgumentNullException(nameof(requiredPackageIds));
}
if (packagesConfig == null)
{
throw new ArgumentNullException(nameof(packagesConfig));
}
if (preferredVersions == null)
{
throw new ArgumentNullException(nameof(preferredVersions));
}
if (availablePackages == null)
{
throw new ArgumentNullException(nameof(availablePackages));
}
DependencyBehavior = dependencyBehavior;
TargetIds = new HashSet<string>(targetIds, StringComparer.OrdinalIgnoreCase);
RequiredPackageIds = new HashSet<string>(requiredPackageIds, StringComparer.OrdinalIgnoreCase);
RequiredPackageIds.UnionWith(targetIds);
PackagesConfig = packagesConfig;
PreferredVersions = new HashSet<PackageIdentity>(preferredVersions, PackageIdentity.Comparer);
AvailablePackages = availablePackages;
Debug.Assert(PreferredVersions.GroupBy(p => p.Id, StringComparer.OrdinalIgnoreCase)
.All(group => group.Count() == 1), "duplicate preferred ids");
}
public void HiloCannotGoDown()
{
using (var store = NewDocumentStore())
{
store.DatabaseCommands.Put(
"Raven/Hilo/Users", null,
new RavenJObject
{
{"Max", 32}
},
new RavenJObject());
var hiLoKeyGenerator = new HiLoKeyGenerator("Users", 32);
var ids = new HashSet<long> { hiLoKeyGenerator.NextId(store.DatabaseCommands) };
store.DatabaseCommands.Put(
"Raven/Hilo/Users", null,
new RavenJObject
{
{"Max", 12}
},
new RavenJObject());
for (int i = 0; i < 128; i++)
{
Assert.True(ids.Add(hiLoKeyGenerator.NextId(store.DatabaseCommands)), "Failed at " + i);
}
var list = ids.GroupBy(x => x).Select(g => new
{
g.Key,
Count = g.Count()
}).Where(x => x.Count > 1).ToList();
Assert.Empty(list);
}
}
/// <summary>
/// Generates a syntax tree for the provided assemblies.
/// </summary>
/// <param name="assemblies">The assemblies to generate code for.</param>
/// <param name="runtime">Whether or not runtime code generation is being performed.</param>
/// <returns>The generated syntax tree.</returns>
private static GeneratedSyntax GenerateForAssemblies(List<Assembly> assemblies, bool runtime)
{
if (Logger.IsVerbose)
{
Logger.Verbose(
"Generating code for assemblies: {0}",
string.Join(", ", assemblies.Select(_ => _.FullName)));
}
Assembly targetAssembly;
HashSet<Type> ignoredTypes;
if (runtime)
{
// Ignore types which have already been accounted for.
ignoredTypes = GetTypesWithGeneratedSupportClasses();
targetAssembly = null;
}
else
{
ignoredTypes = new HashSet<Type>();
targetAssembly = assemblies.FirstOrDefault();
}
var members = new List<MemberDeclarationSyntax>();
// If any KnownAssemblies have been specified, include them during code generation.
var knownAssemblies =
assemblies.SelectMany(_ => _.GetCustomAttributes<KnownAssemblyAttribute>())
.Select(_ => _.Assembly)
.Distinct()
.ToSet();
if (knownAssemblies.Count > 0)
{
knownAssemblies.UnionWith(assemblies);
assemblies = knownAssemblies.ToList();
}
// Get types from assemblies which reference Orleans and are not generated assemblies.
var includedTypes = new HashSet<Type>();
for (var i = 0; i < assemblies.Count; i++)
{
var assembly = assemblies[i];
foreach (var attribute in assembly.GetCustomAttributes<KnownTypeAttribute>())
{
ConsiderType(attribute.Type, runtime, targetAssembly, includedTypes);
}
foreach (var type in assembly.DefinedTypes)
{
ConsiderType(type, runtime, targetAssembly, includedTypes);
}
}
includedTypes.RemoveWhere(_ => ignoredTypes.Contains(_));
// Group the types by namespace and generate the required code in each namespace.
foreach (var group in includedTypes.GroupBy(_ => CodeGeneratorCommon.GetGeneratedNamespace(_)))
{
var namespaceMembers = new List<MemberDeclarationSyntax>();
foreach (var type in group)
{
// The module containing the serializer.
var module = runtime ? null : type.Module;
// Every type which is encountered must be considered for serialization.
Action<Type> onEncounteredType = encounteredType =>
{
// If a type was encountered which can be accessed, process it for serialization.
SerializerGenerationManager.RecordTypeToGenerate(encounteredType, module, targetAssembly);
};
if (Logger.IsVerbose2)
{
Logger.Verbose2("Generating code for: {0}", type.GetParseableName());
}
if (GrainInterfaceData.IsGrainInterface(type))
{
if (Logger.IsVerbose2)
{
Logger.Verbose2(
"Generating GrainReference and MethodInvoker for {0}",
type.GetParseableName());
}
GrainInterfaceData.ValidateInterfaceRules(type);
namespaceMembers.Add(GrainReferenceGenerator.GenerateClass(type, onEncounteredType));
namespaceMembers.Add(GrainMethodInvokerGenerator.GenerateClass(type));
}
// Generate serializers.
var first = true;
Type toGen;
while (SerializerGenerationManager.GetNextTypeToProcess(out toGen))
{
if (!runtime)
{
if (first)
{
ConsoleText.WriteStatus("ClientGenerator - Generating serializer classes for types:");
first = false;
}
ConsoleText.WriteStatus(
"\ttype " + toGen.FullName + " in namespace " + toGen.Namespace
+ " defined in Assembly " + toGen.Assembly.GetName());
}
if (Logger.IsVerbose2)
{
Logger.Verbose2(
"Generating & Registering Serializer for Type {0}",
toGen.GetParseableName());
}
namespaceMembers.AddRange(SerializerGenerator.GenerateClass(toGen, onEncounteredType));
}
}
if (namespaceMembers.Count == 0)
{
if (Logger.IsVerbose)
{
Logger.Verbose2("Skipping namespace: {0}", group.Key);
}
continue;
}
members.Add(
SF.NamespaceDeclaration(SF.ParseName(group.Key))
.AddUsings(
TypeUtils.GetNamespaces(typeof(TaskUtility), typeof(GrainExtensions))
.Select(_ => SF.UsingDirective(SF.ParseName(_)))
.ToArray())
.AddMembers(namespaceMembers.ToArray()));
}
return new GeneratedSyntax
{
SourceAssemblies = assemblies,
Syntax = members.Count > 0 ? SF.CompilationUnit().AddMembers(members.ToArray()) : null
};
}
private void MarkMessages()
{
HashSet<MarkRequest> hash;
using (_rwLock.GetReadLock())
hash = new HashSet<MarkRequest>(_requests);
foreach (var group in hash
.GroupBy(rq => rq.IsRead)
.Select(grp => new { IsRead = grp.Key, Ids = grp.SelectMany(rq => rq.MsgIds) }))
MarkMsgsRead(
_provider,
group.Ids,
group.IsRead);
using (_rwLock.GetWriteLock())
_requests.RemoveAll(hash.Contains);
foreach (var notificator in hash.Select(rq => rq.MarkFinished))
notificator();
}
/// <summary>
/// Generates a syntax tree for the provided assemblies.
/// </summary>
/// <param name="assemblies">The assemblies to generate code for.</param>
/// <param name="runtime">Whether or not runtime code generation is being performed.</param>
/// <returns>The generated syntax tree.</returns>
private static GeneratedSyntax GenerateForAssemblies(List<Assembly> assemblies, bool runtime)
{
if (Logger.IsVerbose)
{
Logger.Verbose(
"Generating code for assemblies: {0}",
string.Join(", ", assemblies.Select(_ => _.FullName)));
}
Assembly targetAssembly;
HashSet<Type> ignoredTypes;
if (runtime)
{
// Ignore types which have already been accounted for.
ignoredTypes = CodeGeneratorCommon.GetTypesWithImplementations(
typeof(MethodInvokerAttribute),
typeof(GrainReferenceAttribute),
typeof(GrainStateAttribute),
typeof(SerializerAttribute));
targetAssembly = null;
}
else
{
ignoredTypes = new HashSet<Type>();
targetAssembly = assemblies.FirstOrDefault();
}
var members = new List<MemberDeclarationSyntax>();
// Get types from assemblies which reference Orleans and are not generated assemblies.
var includedTypes = new HashSet<Type>();
foreach (var type in assemblies.SelectMany(_ => _.DefinedTypes))
{
// The module containing the serializer.
var module = runtime ? null : type.Module;
var typeInfo = type.GetTypeInfo();
// Every type which is encountered must be considered for serialization.
if (!typeInfo.IsNested && !typeInfo.IsGenericParameter && typeInfo.IsSerializable)
{
// If a type was encountered which can be accessed, process it for serialization.
var isAccessibleForSerialization =
!TypeUtilities.IsTypeIsInaccessibleForSerialization(type, module, targetAssembly);
if (isAccessibleForSerialization)
{
includedTypes.Add(type);
SerializerGenerationManager.RecordTypeToGenerate(type);
}
}
// Collect the types which require code generation.
if (GrainInterfaceData.IsGrainInterface(type))
{
if (Logger.IsVerbose2)
{
Logger.Verbose2("Will generate code for: {0}", type.GetParseableName());
}
includedTypes.Add(type);
}
}
includedTypes.RemoveWhere(_ => ignoredTypes.Contains(_));
// Group the types by namespace and generate the required code in each namespace.
foreach (var group in includedTypes.GroupBy(_ => CodeGeneratorCommon.GetGeneratedNamespace(_)))
{
var namespaceMembers = new List<MemberDeclarationSyntax>();
foreach (var type in group)
{
// The module containing the serializer.
var module = runtime ? null : type.Module;
// Every type which is encountered must be considered for serialization.
Action<Type> onEncounteredType = encounteredType =>
{
// If a type was encountered which can be accessed, process it for serialization.
var isAccessibleForSerialization =
!TypeUtilities.IsTypeIsInaccessibleForSerialization(encounteredType, module, targetAssembly);
if (isAccessibleForSerialization)
{
SerializerGenerationManager.RecordTypeToGenerate(encounteredType);
}
};
if (Logger.IsVerbose2)
{
Logger.Verbose2("Generating code for: {0}", type.GetParseableName());
}
if (GrainInterfaceData.IsGrainInterface(type))
{
if (Logger.IsVerbose2)
{
Logger.Verbose2(
"Generating GrainReference and MethodInvoker for {0}",
type.GetParseableName());
}
namespaceMembers.Add(GrainReferenceGenerator.GenerateClass(type, onEncounteredType));
namespaceMembers.Add(GrainMethodInvokerGenerator.GenerateClass(type));
}
// Generate serializers.
var first = true;
Type toGen;
while (SerializerGenerationManager.GetNextTypeToProcess(out toGen))
{
// Filter types which are inaccessible by the serialzation module/assembly.
var skipSerialzerGeneration =
toGen.GetAllFields()
.Any(
field =>
TypeUtilities.IsTypeIsInaccessibleForSerialization(
field.FieldType,
module,
targetAssembly));
if (skipSerialzerGeneration)
{
continue;
}
if (!runtime)
{
if (first)
{
ConsoleText.WriteStatus("ClientGenerator - Generating serializer classes for types:");
first = false;
}
ConsoleText.WriteStatus(
"\ttype " + toGen.FullName + " in namespace " + toGen.Namespace
+ " defined in Assembly " + toGen.Assembly.GetName());
}
if (Logger.IsVerbose2)
{
Logger.Verbose2(
"Generating & Registering Serializer for Type {0}",
toGen.GetParseableName());
}
namespaceMembers.AddRange(SerializerGenerator.GenerateClass(toGen, onEncounteredType));
}
}
if (namespaceMembers.Count == 0)
{
if (Logger.IsVerbose)
{
Logger.Verbose2("Skipping namespace: {0}", group.Key);
}
continue;
}
members.Add(
SF.NamespaceDeclaration(SF.ParseName(group.Key))
.AddUsings(
TypeUtils.GetNamespaces(typeof(TaskUtility), typeof(GrainExtensions))
.Select(_ => SF.UsingDirective(SF.ParseName(_)))
.ToArray())
.AddMembers(namespaceMembers.ToArray()));
}
return new GeneratedSyntax
{
SourceAssemblies = assemblies,
Syntax = members.Count > 0 ? SF.CompilationUnit().AddMembers(members.ToArray()) : null
};
}
private void Initialize()
{
if (null == _consumingMethod)
throw new InvalidOperationException("Consuming method has not been defined");
if (!_assemblies.Any())
throw new InvalidOperationException("There are no assemblies to scan");
var types = _assemblies
.SelectMany(a => {
try
{
return a.GetExportedTypes();
} catch{}
return new Type[0];
}).Where(x=>x!=null)
.ToList();
var messageTypes = types.Where(x => !x.IsInterface && typeof(IMessage).IsAssignableFrom(x)).ToArray();
var consumerTypes = types.Where(x => typeof(IConsume).IsAssignableFrom(x)).ToArray();
var consumingDirectly = consumerTypes
.SelectMany(consumerType =>
GetConsumedMessages(consumerType)
.Select(messageType => new MessageMapping(consumerType, messageType, true)))
.ToArray();
var result = new HashSet<MessageMapping>();
foreach (var m in consumingDirectly)
{
result.Add(m);
}
var allMessages = result.Select(m => m.Message).ToList();
foreach (var messageType in messageTypes)
{
if (!allMessages.Contains(messageType))
{
allMessages.Add(messageType);
result.Add(new MessageMapping(typeof(MessageMapping.BusNull), messageType, true));
}
}
_consumerInfos = result
.GroupBy(x => x.Consumer)
.Select(x =>
{
var directs = x
.Where(m => m.Direct)
.Select(m => m.Message)
.Distinct();
var assignables = x
.Select(m => m.Message)
.Where(t => directs.Any(d => d.IsAssignableFrom(t)))
.Distinct();
return new ConsumerInfo(x.Key, assignables.ToArray());
}).ToList();
_messageInfos = result
.ToLookup(x => x.Message)
.Select(x =>
{
var domainConsumers = x
.Where(t => t.Consumer != typeof(MessageMapping.BusNull))
.ToArray();
return new MessageInfo
{
MessageType = x.Key,
AllConsumers = domainConsumers.Select(m => m.Consumer).Distinct().ToArray(),
DerivedConsumers = domainConsumers.Where(m => !m.Direct).Select(m => m.Consumer).Distinct().ToArray(),
DirectConsumers = domainConsumers.Where(m => m.Direct).Select(m => m.Consumer).Distinct().ToArray(),
};
}).ToList();
var includedTypes = _messageInfos
.Select(m => m.MessageType).ToList();
// message directory should still include all messages for the serializers
var orphanedMessages = result
.Where(m => !includedTypes.Contains(m.Message))
.Select(m => new MessageInfo
{
MessageType = m.Message,
AllConsumers = Type.EmptyTypes,
DerivedConsumers = Type.EmptyTypes,
DirectConsumers = Type.EmptyTypes
});
_messageInfos.AddRange(orphanedMessages);
}
static int Main(string[] args)
{
#region Command Line argument processing
if ( args.Contains ("--help") )
{
Console.WriteLine ("This tool depends on Microsoft Office 2010+");
Console.WriteLine ("Valid switches are");
Console.WriteLine ("-ignore <comma separated list of file extn> : Ignore line with pattern");
Console.WriteLine ("-include <comma separated list of file extn> : Filter for pattern");
Console.WriteLine ("-concurrency <No of minutes> : Concurrency Window in minutes");
Console.WriteLine ("-toppages <No of pages> : No of Top Pages/day");
Console.WriteLine ("-peaks <No of peaks> : No of Peak Hours to consider");
Console.WriteLine ("-param <comma seperated list of patterns> : Summarize specific URL parameters");
Console.WriteLine ("-export <export filename> : Excel file report name, default will be with time stamp");
Console.WriteLine ("-folder <log file folder path> : Current folder will be defaulted. All .log files in this folder will be processed.");
Console.WriteLine ("Add a space after the pattern if you want extension mapping (e.g. .aspx ,.jpg)");
return 0;
}
if ( args.Length % 2 != 0 )
{
throw new ArgumentException ("Command line arguments not valid, try --help to see valid ones!");
}
Dictionary<string, string> cmdArgs = new Dictionary<string, string> ();
for ( int i = 0; i < args.Length; i += 2 )
{
cmdArgs.Add (args[i].ToLower (), args[i + 1]);
}
List<string> ignoredTypes = new List<string> (), filterTypes = new List<string> (), hitsPerURLParams = new List<string> ();
if ( cmdArgs.ContainsKey (IgnoreSwitch) )
{
ignoredTypes = cmdArgs[IgnoreSwitch].ToLower ().Split (',').ToList ();
}
if ( cmdArgs.ContainsKey (FilterSwitch) )
{
filterTypes = cmdArgs[FilterSwitch].ToLower ().Split (',').ToList ();
}
if ( cmdArgs.ContainsKey (URLParamsSwitch) )
{
hitsPerURLParams = cmdArgs[URLParamsSwitch].ToLower ().Split (',').ToList ();
}
float concurrencyWindow = 5;
if ( cmdArgs.ContainsKey (ConcurrencySwitch) )
{
concurrencyWindow = float.Parse (cmdArgs[ConcurrencySwitch]);
}
else
cmdArgs.Add (ConcurrencySwitch, concurrencyWindow.ToString ());
int topPagesPerDay = 10;
if ( cmdArgs.ContainsKey (TopPagesSwitch) )
{
topPagesPerDay = int.Parse (cmdArgs[TopPagesSwitch]);
}
else
cmdArgs.Add (TopPagesSwitch, topPagesPerDay.ToString ());
int peakHoursCount = 3;
if ( cmdArgs.ContainsKey (PeakHoursSwitch) )
{
peakHoursCount = int.Parse (cmdArgs[PeakHoursSwitch]);
}
else
cmdArgs.Add (PeakHoursSwitch, peakHoursCount.ToString ());
string exportFileName = null;
if ( cmdArgs.ContainsKey (ExportFileSwitch) )
{
try
{
exportFileName = Path.GetFullPath (cmdArgs[ExportFileSwitch]);
}
catch ( Exception e )
{
Console.WriteLine ("Error creating report file:{0},{1}", e.GetType ().Name, e.Message);
}
}
if ( exportFileName == null )
{
exportFileName = Path.GetFullPath ("Processing results_" + DateTime.Now.ToString ("dd_hh_mm") + ".xlsx");
Console.WriteLine ("Writing output to {0}", exportFileName);
}
string curerntPath;
if ( cmdArgs.ContainsKey (FolderSwitch) )
{
try
{
curerntPath = Path.GetFullPath (cmdArgs[FolderSwitch]);
}
catch ( Exception e )
{
Console.WriteLine ("Error accessing folder {0}:{1},{2}", cmdArgs[FolderSwitch], e.GetType ().Name, e.Message);
return 1;
}
}
else
{
curerntPath = Directory.GetCurrentDirectory ();
Console.WriteLine ("Working on IIS logs from current folder {0}", curerntPath);
}
#endregion
Stopwatch stopWatch = new Stopwatch ();
stopWatch.Start ();
//var files = Directory.GetFiles(curerntPath, "*.log").ToList();
var files = new DirectoryInfo (curerntPath)
.GetFiles ("*.log")
.OrderBy (f => f.LastWriteTime)
.Select (f => f.FullName)
.ToArray ();
var totalFile = files.Count ();
if ( totalFile == 0 )
{
Console.WriteLine ("No log files found!!");
return 0;
}
Console.WriteLine ("Found {0} log files", totalFile);
var tmpFile = System.IO.Path.GetTempFileName ();
int fileCount = 0;
int headerRows = 4;
int entryCount = 0;
List<IISLogEntry> processingList = new List<IISLogEntry> ();
DateTime nextTime = DateTime.MinValue;
long TotalHits = 0, ServedRequests = 0;
List<ConcurrentRequest> requests = new List<ConcurrentRequest> ();
HashSet<string> uniqueIPs = new HashSet<string> ();
Dictionary<int, int> httpStatus = new Dictionary<int, int> ();
Dictionary<string, MethodInfo> pageViewsForPeriod = new Dictionary<string, MethodInfo> ();
int totalDays = 0, totalHours = 0;
Dictionary<string, MethodInfo> pageViewsDaily = new Dictionary<string, MethodInfo> ();
HashSet<MethodInfo> dailyPages = new HashSet<MethodInfo> ();
Dictionary<string, MethodInfo> pageViewsHourly = new Dictionary<string, MethodInfo> ();
HashSet<MethodInfo> hourlyPages = new HashSet<MethodInfo> ();
//hits for key URL parameters
Dictionary<string, MethodInfo> urlParamHits = new Dictionary<string, MethodInfo> ();
DateTime firstEntry = DateTime.MinValue, lastEntry = DateTime.MinValue;
//placeholder
HashSet<MethodInfo> filteredEntries = new HashSet<MethodInfo> ();
int startRow = 1, startCol = 1;
int reportRow = 2, reportCol = 1;
Console.WriteLine ("Preparing to Process..");
foreach ( var f in files )
{
try
{
++fileCount;
var progress = fileCount * 100 / totalFile;
IEnumerable<string> matchedEntries = null;
var contents = File.ReadLines (f);
Dictionary<string, int> fieldIndex = new Dictionary<string, int> ();
#region Content filter
if ( filterTypes.Any () && ignoredTypes.Any () )
matchedEntries = contents.Where (s => s.StartsWith ("#") ||
( filterTypes.Any (x => s.ToLower ().Contains (x)) &&
!ignoredTypes.Any (x => s.ToLower ().Contains (x)) ));
else if ( filterTypes.Any () )
matchedEntries = contents.Where (s => s.StartsWith ("#") || filterTypes.Any (x => s.ToLower ().Contains (x)));
else if ( ignoredTypes.Any () )
matchedEntries = contents.Where (s => s.StartsWith ("#") || !ignoredTypes.Any (x => s.ToLower ().Contains (x)));
else
matchedEntries = contents;
foreach ( var rawLogEntry in matchedEntries )
{
IISLogEntry logEntry;
if ( rawLogEntry.StartsWith ("#") )
{
if ( rawLogEntry.StartsWith ("#Fields:") )
fieldIndex = ParseHeaderFields (rawLogEntry);
}
else
{
Console.Write ("\r{0} File {1} of {2} files ({3}%), processing {4} ", stopWatch.Elapsed.ToString (@"hh\:mm\:ss"), fileCount, totalFile, progress, ++TotalHits);
var columns = rawLogEntry.Split (' ');
logEntry = new IISLogEntry ()
{
TimeStamp = DateTime.Parse (columns[0] + " " + columns[1]),
ClientIPAddress = fieldIndex.ContainsKey (IISLogEntry.propClientIPAddress) ? columns[fieldIndex[IISLogEntry.propClientIPAddress]] : String.Empty,
UserName = fieldIndex.ContainsKey (IISLogEntry.propUserName) ? columns[fieldIndex[IISLogEntry.propUserName]] : String.Empty,
ServiceNameandInstanceNumber = fieldIndex.ContainsKey (IISLogEntry.propServiceNameandInstanceNumber) ? columns[fieldIndex[IISLogEntry.propServiceNameandInstanceNumber]] : String.Empty,
ServerName = fieldIndex.ContainsKey (IISLogEntry.propServerName) ? columns[fieldIndex[IISLogEntry.propServerName]] : String.Empty,
ServerIPAddress = fieldIndex.ContainsKey (IISLogEntry.propServerIPAddress) ? columns[fieldIndex[IISLogEntry.propServerIPAddress]] : String.Empty,
ServerPort = fieldIndex.ContainsKey (IISLogEntry.propClientIPAddress) ? Int32.Parse (columns[fieldIndex[IISLogEntry.propServerPort]]) : 0,
Method = fieldIndex.ContainsKey (IISLogEntry.propMethod) ? columns[fieldIndex[IISLogEntry.propMethod]] : String.Empty,
URIStem = fieldIndex.ContainsKey (IISLogEntry.propURIStem) ? columns[fieldIndex[IISLogEntry.propURIStem]] : String.Empty,
URIQuery = fieldIndex.ContainsKey (IISLogEntry.propURIQuery) ? columns[fieldIndex[IISLogEntry.propURIQuery]] : String.Empty,
HTTPStatus = fieldIndex.ContainsKey (IISLogEntry.propHTTPStatus) ? Int32.Parse (columns[fieldIndex[IISLogEntry.propHTTPStatus]]) : 0,
//Win32Status = fieldIndex.ContainsKey(IISLogEntry.propWin32Status) ? Int32.Parse(row[fieldIndex[IISLogEntry.propWin32Status]]) : 0,
BytesSent = fieldIndex.ContainsKey (IISLogEntry.propBytesSent) ? Int32.Parse (columns[fieldIndex[IISLogEntry.propBytesSent]]) : 0,
BytesReceived = fieldIndex.ContainsKey (IISLogEntry.propBytesReceived) ? Int32.Parse (columns[fieldIndex[IISLogEntry.propBytesReceived]]) : 0,
TimeTaken = fieldIndex.ContainsKey (IISLogEntry.propTimeTaken) ? Int32.Parse (columns[fieldIndex[IISLogEntry.propTimeTaken]]) : 0,
ProtocolVersion = fieldIndex.ContainsKey (IISLogEntry.propProtocolVersion) ? columns[fieldIndex[IISLogEntry.propProtocolVersion]] : String.Empty,
Host = fieldIndex.ContainsKey (IISLogEntry.propHost) ? columns[fieldIndex[IISLogEntry.propHost]] : String.Empty,
UserAgent = fieldIndex.ContainsKey (IISLogEntry.propUserAgent) ? columns[fieldIndex[IISLogEntry.propUserAgent]] : String.Empty,
Cookie = fieldIndex.ContainsKey (IISLogEntry.propCookie) ? columns[fieldIndex[IISLogEntry.propCookie]] : String.Empty,
Referrer = fieldIndex.ContainsKey (IISLogEntry.propReferrer) ? columns[fieldIndex[IISLogEntry.propReferrer]] : String.Empty,
ProtocolSubstatus = fieldIndex.ContainsKey (IISLogEntry.propProtocolSubstatus) ? columns[fieldIndex[IISLogEntry.propProtocolSubstatus]] : String.Empty
};
#endregion
#region entry processing
var url = logEntry.URIStem.ToLower ();
#region HTTP status codes & IP
if ( httpStatus.ContainsKey (logEntry.HTTPStatus) )
httpStatus[logEntry.HTTPStatus]++;
else
httpStatus.Add (logEntry.HTTPStatus, 1);
if ( !uniqueIPs.Contains (logEntry.ClientIPAddress) )
uniqueIPs.Add (logEntry.ClientIPAddress);
#endregion
if ( nextTime == DateTime.MinValue )
{
firstEntry = logEntry.TimeStamp;
lastEntry = logEntry.TimeStamp;
nextTime = logEntry.TimeStamp.Date.
AddHours (logEntry.TimeStamp.Hour).
AddMinutes (logEntry.TimeStamp.Minute).
AddMinutes (concurrencyWindow);
}
if ( logEntry.TimeStamp > nextTime )
{
if ( processingList.Any () )
{
requests.Add (new ConcurrentRequest (concurrencyWindow)
{
TimeStamp = nextTime,
Transactions = processingList.Count,
AverageResponseTime = processingList.Average (p => p.TimeTaken),
BytesSent = processingList.Sum (t => t.BytesSent)
});
processingList.Clear ();
}
else
{
requests.Add (new ConcurrentRequest (concurrencyWindow)
{
TimeStamp = nextTime,
Transactions = 0,
AverageResponseTime = 0,
BytesSent = 0
});
}
nextTime = nextTime.AddMinutes (concurrencyWindow);
}
if ( lastEntry.Hour != logEntry.TimeStamp.Hour )
{
totalHours++;
AddHourlyPages (pageViewsHourly, hourlyPages, lastEntry);
}
if ( lastEntry.Date != logEntry.TimeStamp.Date )
{
totalDays++;
AddDailyPages (pageViewsDaily, dailyPages, lastEntry);
}
//add the current one to future processing, otherwise one in teh borderlien will be missing
if ( logEntry.HTTPStatus == 200 )
{
processingList.Add (logEntry);
ServedRequests++;
if ( pageViewsForPeriod.ContainsKey (url) )
pageViewsForPeriod[url].Hit (logEntry.TimeTaken);
else
pageViewsForPeriod.Add (url, new MethodInfo (logEntry.URIStem, logEntry.TimeTaken));
if ( lastEntry.Hour == logEntry.TimeStamp.Hour )
{
if ( pageViewsHourly.ContainsKey (url) )
pageViewsHourly[url].Hit (logEntry.TimeTaken);
else
pageViewsHourly.Add (url, new MethodInfo (logEntry.URIStem, logEntry.TimeTaken));
}
if ( lastEntry.Date == logEntry.TimeStamp.Date )
{
if ( pageViewsDaily.ContainsKey (url) )
pageViewsDaily[url].Hit (logEntry.TimeTaken);
else
pageViewsDaily.Add (url, new MethodInfo (logEntry.URIStem, logEntry.TimeTaken));
}
if ( hitsPerURLParams.Any () )
{
var urlParam = hitsPerURLParams.Where (p => logEntry.URIQuery.Contains (p)).FirstOrDefault ();
if ( urlParam != null && urlParam != String.Empty )
{
if ( urlParamHits.ContainsKey (url) )
urlParamHits[url].Hit (logEntry.TimeTaken);
else
urlParamHits.Add (url, new MethodInfo (urlParam, logEntry.TimeTaken));
}
}
}
lastEntry = logEntry.TimeStamp;
}
}
if ( processingList.Any () )
{
requests.Add (new ConcurrentRequest (concurrencyWindow)
{
TimeStamp = nextTime,
Transactions = processingList.Count,
AverageResponseTime = processingList.Average (p => p.TimeTaken),
BytesSent = processingList.Sum (t => t.BytesSent)
});
processingList.Clear ();
}
AddHourlyPages (pageViewsHourly, hourlyPages, lastEntry);
AddDailyPages (pageViewsDaily, dailyPages, lastEntry);
#endregion
}
catch ( Exception e )
{
Console.WriteLine ("Error!! {0}:{1} - {2}", e.GetType ().Name, e.Message, e.StackTrace);
Debug.WriteLine ("Error!! {0}:{1}", e.GetType ().Name, e.Message);
}
}
Console.WriteLine ("\nGenerating Statistics");
#region resultprocessing
IEnumerable<MethodInfo> topPages;
IEnumerable<IGrouping<DateTime, MethodInfo>> hourlyHits = null;
long peakHits;
IEnumerable<IGrouping<DateTime, MethodInfo>> peakHourPages = null;
try
{
excelApp = new Application ();
excelApp.Visible = false;
reportSpreadsheet = excelApp.Workbooks.Add ();
excelApp.Calculation = XlCalculation.xlCalculationManual;
reportSheet = reportSpreadsheet.ActiveSheet;
#region Concurrent Users
if ( requests.Any () )
{
Console.WriteLine ("{0} Calculating Concurrent User Count", stopWatch.Elapsed.ToString (@"hh\:mm\:ss"));
reportSheet.Name = "Concurrent Users";
reportSheet.Cells[reportRow, reportCol++] = "Timestamp";
reportSheet.Cells[reportRow, reportCol++] = "Requests";
reportSheet.Cells[reportRow, reportCol++] = "TPS";
reportSheet.Cells[reportRow, reportCol++] = "Average Response Time";
reportSheet.Cells[reportRow, reportCol++] = "Concurrent Users (based on Little's Law)";
reportSheet.Cells[reportRow, reportCol++] = "Bytes Sent";
reportSheet.Cells[reportRow, reportCol++] = "Network Speed (Mbps)";
foreach ( var p in requests )
{
reportCol = 1; reportRow++;
reportSheet.Cells[reportRow, reportCol++] = p.TimeStamp;
reportSheet.Cells[reportRow, reportCol++] = p.Transactions;
reportSheet.Cells[reportRow, reportCol++] = p.Tps;
reportSheet.Cells[reportRow, reportCol++] = p.AverageResponseTime;
reportSheet.Cells[reportRow, reportCol++] = p.ConcurrentUsers;
reportSheet.Cells[reportRow, reportCol++] = p.BytesSent;
reportSheet.Cells[reportRow, reportCol++] = p.NetworkSpeed;
}
}
#endregion
reportSpreadsheet.Application.DisplayAlerts = false;
reportSpreadsheet.SaveAs (exportFileName, ConflictResolution: XlSaveConflictResolution.xlLocalSessionChanges);
#region Page visit Summary
if ( pageViewsForPeriod.Any () )
{
Console.WriteLine ("{0} Genrating Page visit Summary", stopWatch.Elapsed.ToString (@"hh\:mm\:ss"));
reportSheet = reportSpreadsheet.Worksheets.Add (Type.Missing, reportSheet, 1);
reportSheet.Name = "Page visit Summary";
startRow = startCol = 1;
startRow = CollectionToTable (pageViewsForPeriod.Values, startRow, startCol, "Page visit Summary (for the period)");
reportSheet.Shapes.AddChart (XlChartType.xlLine).Select ();
excelApp.ActiveChart.SetSourceData (Source: reportSheet.get_Range ("A1:B" + startRow));
reportSheet.Shapes.AddChart (XlChartType.xlPie).Select ();
excelApp.ActiveChart.SetSourceData (Source: reportSheet.get_Range ("A1:B" + startRow));
excelApp.ActiveChart.ClearToMatchStyle ();
try
{
excelApp.ActiveChart.ChartStyle = 256;
}
catch ( Exception e )
{ }
excelApp.ActiveChart.SetElement (Microsoft.Office.Core.MsoChartElementType.msoElementChartTitleAboveChart);
excelApp.ActiveChart.ChartTitle.Text = "Page visit Summary (for the period) Most Visited Pages";
reportSheet.Shapes.AddChart (XlChartType.xlBarClustered).Select ();
excelApp.ActiveChart.SetSourceData (Source: reportSheet.get_Range ("A1:D" + startRow));
excelApp.ActiveChart.ClearToMatchStyle ();
try
{
excelApp.ActiveChart.ChartStyle = 222;
}
catch ( Exception e )
{ }
excelApp.ActiveChart.SetElement (Microsoft.Office.Core.MsoChartElementType.msoElementChartTitleAboveChart);
excelApp.ActiveChart.ChartTitle.Text = "Page visit Summary (for the period) Average Response Time";
SpreadCharts (reportSheet);
}
#endregion
#region Daily Analysis
if ( dailyPages.Any () )
{
Console.WriteLine ("{0} Genrating Daily Statistics", stopWatch.Elapsed.ToString (@"hh\:mm\:ss"));
reportSheet = reportSpreadsheet.Worksheets.Add (Type.Missing, reportSheet, 1);
reportSheet.Name = "Daily Analysis";
foreach ( var d in dailyPages.Select (p => p.Timestamp).Distinct () )
{
filteredEntries.UnionWith (dailyPages.Where (p => p.Timestamp == d.Date)
.OrderByDescending (p => p.Hits).Take (topPagesPerDay));
//Debug.WriteLine("Date: {0} - {1}", date, MethodInfo.TotalHits(dailyPages.Where(p => p.Timestamp == d.Date)));
}
topPages = filteredEntries.Where (p => filteredEntries.Count (q => q.Url == p.Url) > totalDays / 2);
startRow = startCol = 1;
AddChartFromSeries (startRow, startCol, "Daily Top Pages - Visits Trend", topPages, p => p.Hits, d => d.ToString (DateTimeFormatInfo.CurrentInfo.ShortDatePattern));
startRow = reportRow + 10;
startCol = 1;
AddChartFromSeries (startRow, startCol, "Daily Top Pages - Response Time(Average) Trend", topPages, p => p.AvgResponseTime, d => d.ToString (DateTimeFormatInfo.CurrentInfo.ShortDatePattern));
startRow = reportRow + 10;
startCol = 1;
AddChartFromSeries (startRow, startCol, "Daily Top Pages - Response Time(90%tile) Trend", topPages, p => p.NinetiethPercentile, d => d.ToString (DateTimeFormatInfo.CurrentInfo.ShortDatePattern));
startRow = 1;
startCol = 30;
filteredEntries.Clear ();
//reportSheet.Cells[reportRow, reportCol] = "Date";
foreach ( var d in dailyPages.Select (p => p.Timestamp).Distinct () )
{
filteredEntries.UnionWith (dailyPages.Where (p => p.Timestamp == d.Date)
.OrderByDescending (p => p.NinetiethPercentile).Take (topPagesPerDay));
}
topPages = filteredEntries.Where (p => filteredEntries.Count (q => q.Url == p.Url) > totalDays / 2);
AddChartFromSeries (startRow, startCol, "Daily Slow Pages - Response Time(90%tile) Trend", topPages, p => p.NinetiethPercentile, d => d.ToString (DateTimeFormatInfo.CurrentInfo.ShortDatePattern));
startRow = reportRow + 10;
startCol = 30;
filteredEntries.Clear ();
//reportSheet.Cells[reportRow, reportCol] = "Date";
foreach ( var d in dailyPages.Select (p => p.Timestamp).Distinct () )
{
filteredEntries.UnionWith (dailyPages.Where (p => p.Timestamp == d.Date)
.OrderByDescending (p => p.AvgResponseTime).Take (topPagesPerDay));
//Debug.WriteLine("Date: {0} - {1}", date, MethodInfo.TotalHits(dailyPages.Where(p => p.Timestamp == d.Date)));
}
topPages = filteredEntries.Where (p => filteredEntries.Count (q => q.Url == p.Url) > totalDays / 2);
AddChartFromSeries (startRow, startCol, "Daily Slow Pages - Response Time(Average) Trend", topPages, p => p.AvgResponseTime, d => d.ToString (DateTimeFormatInfo.CurrentInfo.ShortDatePattern));
SpreadCharts (reportSheet);
}
#endregion
#region Hourly analysis
if ( hourlyPages.Any () )
{
Console.WriteLine ("{0} Genrating Hourly Statistics", stopWatch.Elapsed.ToString (@"hh\:mm\:ss"));
reportSheet = reportSpreadsheet.Worksheets.Add (Type.Missing, reportSheet, 1);
reportSheet.Name = "Hourly Analysis";
startRow = 1;
startCol = 1;
filteredEntries.Clear ();
foreach ( var d in hourlyPages.Select (p => p.Timestamp).Distinct () )
{
filteredEntries.UnionWith (hourlyPages.Where (p => p.Timestamp == d.Date.AddHours (d.Hour))
.OrderByDescending (p => p.Hits).Take (topPagesPerDay));
//Debug.WriteLine("Date: {0} - {1}", date, MethodInfo.TotalHits(dailyPages.Where(p => p.Timestamp == d.Date)));
}
var totalHits = hourlyPages.Sum (p => p.Hits);
//filter out top pages which are there for 10% of time or 2% traffic
topPages = filteredEntries.Where (p => filteredEntries.Count (q => q.Url == p.Url) > totalHours / 10 || p.Hits > totalHits * 2 / 100);
startRow += AddChartFromSeries (startRow, startCol, "Hourly Top Pages Summary (By Hits)", topPages, p => p.Hits, d => d.ToString ());
excelApp.ActiveChart.Axes (XlAxisType.xlCategory).CategoryType = XlCategoryType.xlCategoryScale;
hourlyHits = hourlyPages.GroupBy (p => p.Timestamp, q => q);
peakHits = hourlyHits.Select (p => p.Sum (q => q.Hits)).OrderByDescending (p => p).Take (peakHoursCount).Min ();
peakHourPages = hourlyHits.Where (p => p.Sum (q => q.Hits) >= peakHits);
startRow += 10; startCol = 1;
startRow += AddChartFromSeries (startRow, startCol, "Peak Hour Top Pages Summary (By Hits)", peakHourPages.SelectMany (g => g.Where (p => p.Hits > peakHits * 2 / 100)), p => p.Hits, d => d.ToString ());
excelApp.ActiveChart.Axes (XlAxisType.xlCategory).CategoryType = XlCategoryType.xlCategoryScale;
CollectionToTable (peakHourPages.SelectMany (g => g), startRow + 10, 1, "Peak Hour Pages", true);
SpreadCharts (reportSheet);
}
#endregion
#region URL Param Hits Summary
if ( hitsPerURLParams.Any () )
{
Console.WriteLine ("{0} Genrating URL parameter statistics", stopWatch.Elapsed.ToString (@"hh\:mm\:ss"));
reportSheet = reportSpreadsheet.Worksheets.Add (Type.Missing, reportSheet, 1);
startRow = startCol = 1;
reportSheet.Name = "URL Parameters";
CollectionToTable (urlParamHits.Values, startRow, startCol, "URL Parameters Summary (for the period)");
}
#endregion
#region Summary
Console.WriteLine ("{0} Genrating Summary", stopWatch.Elapsed.ToString (@"hh\:mm\:ss"));
reportSheet = reportSpreadsheet.Worksheets.Add (reportSheet, Type.Missing, 1);
reportRow = reportCol = 1;
reportSheet.Name = "Summary";
reportSheet.Cells[reportRow, 1] = "Running From";
reportSheet.Cells[reportRow++, 2] = curerntPath;
reportSheet.Cells[reportRow, 1] = "Commandline Argument";
reportSheet.Cells[reportRow++, 2] = string.Join (";", cmdArgs.Select (x => x.Key + "=" + x.Value));
reportSheet.Cells[reportRow, 1] = "Files Processed";
reportSheet.Cells[reportRow++, 2] = fileCount;
reportSheet.Cells[reportRow, 1] = "From";
reportSheet.Cells[reportRow++, 2] = firstEntry;
reportSheet.Cells[reportRow, 1] = "To";
reportSheet.Cells[reportRow++, 2] = lastEntry;
reportSheet.Cells[reportRow, 1] = "TotalHits";
reportSheet.Cells[reportRow++, 2] = TotalHits;
reportSheet.Cells[reportRow, 1] = "Average Transactions/Sec";
reportSheet.Cells[reportRow++, 2] = requests.Average (p => p.Tps);
if ( hourlyHits!=null )
{
reportSheet.Cells[reportRow, 1] = "Average Transactions/Hour";
reportSheet.Cells[reportRow++, 2] = hourlyHits.Average (p => p.Sum (q => q.Hits));
}
if ( peakHourPages!=null )
{
reportSheet.Cells[reportRow, 1] = "Peak Hour Transactions/Hour";
reportSheet.Cells[reportRow++, 2] = peakHourPages.Average (p => p.Sum (q => q.Hits));
reportSheet.Cells[reportRow, 1] = "Peak Hour Transactions/Sec";
reportSheet.Cells[reportRow++, 2] = peakHourPages.Average (p => p.Sum (q => q.Hits) / 3600);
}
reportSheet.Cells[reportRow, 1] = "UniqueIPs";
reportSheet.Cells[reportRow++, 2] = uniqueIPs.Count;
reportSheet.Cells[reportRow, 1] = "ServedRequests";
reportSheet.Cells[reportRow++, 2] = ServedRequests;
reportRow += 10;
reportSheet.Cells[reportRow++, 1] = "Http Status code summary";
reportSheet.Cells[reportRow, 1] = "HTTP Code";
reportSheet.Cells[reportRow++, 2] = "Count";
foreach ( var i in httpStatus )
{
reportSheet.Cells[reportRow, reportCol++] = i.Key;
reportSheet.Cells[reportRow++, reportCol--] = ( i.Value );
}
#endregion
}
catch ( Exception e )
{
Console.WriteLine ("Error!! {0}:{1} - {2}", e.GetType ().Name, e.Message, e.StackTrace);
Debug.WriteLine ("Error!! {0}:{1}", e.GetType ().Name, e.Message);
}
finally
{
if ( excelApp != null )
{
excelApp.Calculation = XlCalculation.xlCalculationAutomatic;
if ( reportSpreadsheet != null )
{
reportSpreadsheet.Save ();
reportSpreadsheet.Close ();
excelApp.Quit ();
}
}
File.Delete (tmpFile);
stopWatch.Stop ();
Console.WriteLine ("Done, Final time : {0}", stopWatch.Elapsed.ToString (@"hh\:mm\:ss"));
}
#endregion
return 0;
}
internal static ReadOnlyCollection<MethodMockableResult> GetMockableMethods(this Type @this, NameGenerator generator)
{
var objectMethods = @this.IsInterface ?
typeof(object).GetMethods().Where(_ => _.IsExtern() || _.IsVirtual).ToList() : new List<MethodInfo>();
var methods = new HashSet<MockableResult<MethodInfo>>(@this.GetMethods(ReflectionValues.PublicNonPublicInstance)
.Where(_ => !_.IsSpecialName && _.IsVirtual && !_.IsFinal &&
!objectMethods.Where(om => om.Match(_) == MethodMatch.Exact).Any() &&
_.DeclaringType.Assembly.CanBeSeenByMockAssembly(_.IsPublic, _.IsPrivate, _.IsFamily, _.IsFamilyOrAssembly, generator))
.Select(_ => new MockableResult<MethodInfo>(_, RequiresExplicitInterfaceImplementation.No)));
if (@this.IsInterface)
{
var namespaces = new SortedSet<string>();
foreach (var @interface in @this.GetInterfaces())
{
var interfaceMethods = @interface.GetMethods()
.Where(_ => !_.IsSpecialName && !objectMethods.Where(om => om.Match(_) == MethodMatch.Exact).Any());
foreach (var interfaceMethod in interfaceMethods)
{
if (interfaceMethod.CanBeSeenByMockAssembly(generator))
{
var matchMethodGroups = methods.GroupBy(_ => interfaceMethod.Match(_.Value)).ToDictionary(_ => _.Key);
if (!matchMethodGroups.ContainsKey(MethodMatch.Exact))
{
methods.Add(new MockableResult<MethodInfo>(
interfaceMethod, matchMethodGroups.ContainsKey(MethodMatch.DifferByReturnTypeOnly) ?
RequiresExplicitInterfaceImplementation.Yes : RequiresExplicitInterfaceImplementation.No));
}
}
}
}
}
var baseStaticMethods = @this.IsInterface ?
typeof(object).GetMethods().Where(_ => _.IsStatic).ToList() :
@this.GetMethods().Where(_ => _.IsStatic).ToList();
return methods.Select(_ => new MethodMockableResult(
_.Value, _.RequiresExplicitInterfaceImplementation,
baseStaticMethods.Where(osm => osm.Match(_.Value) == MethodMatch.Exact).Any() ?
RequiresIsNewImplementation.Yes : RequiresIsNewImplementation.No)).ToList().AsReadOnly();
}
internal static ReadOnlyCollection<PropertyMockableResult> GetMockableProperties(this Type @this, NameGenerator generator)
{
var properties = new HashSet<PropertyMockableResult>(
from property in @this.GetProperties(ReflectionValues.PublicNonPublicInstance)
let canGet = property.CanRead && property.GetMethod.IsVirtual && !property.GetMethod.IsFinal &&
property.GetMethod.DeclaringType.Assembly.CanBeSeenByMockAssembly(
property.GetMethod.IsPublic, property.GetMethod.IsPrivate, property.GetMethod.IsFamily, property.GetMethod.IsFamilyOrAssembly, generator)
let canSet = property.CanWrite && property.SetMethod.IsVirtual && !property.SetMethod.IsFinal &&
property.SetMethod.DeclaringType.Assembly.CanBeSeenByMockAssembly(
property.SetMethod.IsPublic, property.SetMethod.IsPrivate, property.SetMethod.IsFamily, property.SetMethod.IsFamilyOrAssembly, generator)
where canGet || canSet
select new PropertyMockableResult(property, RequiresExplicitInterfaceImplementation.No,
(canGet && canSet ? PropertyAccessors.GetAndSet : (canGet ? PropertyAccessors.Get : PropertyAccessors.Set))));
if (@this.IsInterface)
{
var namespaces = new SortedSet<string>();
foreach (var @interface in @this.GetInterfaces())
{
foreach (var interfaceProperty in @interface.GetMockableProperties(generator))
{
if (interfaceProperty.Value.GetDefaultMethod().CanBeSeenByMockAssembly(generator))
{
var matchMethodGroups = properties.GroupBy(_ => interfaceProperty.Value.GetDefaultMethod().Match(_.Value.GetDefaultMethod())).ToDictionary(_ => _.Key);
if (!matchMethodGroups.ContainsKey(MethodMatch.Exact))
{
properties.Add(new PropertyMockableResult(interfaceProperty.Value,
matchMethodGroups.ContainsKey(MethodMatch.DifferByReturnTypeOnly) ?
RequiresExplicitInterfaceImplementation.Yes : RequiresExplicitInterfaceImplementation.No,
interfaceProperty.Accessors));
}
}
}
}
}
return properties.ToList().AsReadOnly();
}
/// <summary>
/// Check for conflicts of versions in the referenced assemblies of the workflow.
/// </summary>
/// <param name="referencedTypes">Referenced types in the project</param>
/// <param name="referencedAssemblies">Referenced assemblies in the project</param>
/// <param name="projectName">Name of the main type (workflow) of the project</param>
private static void CheckForConflictingVersions(HashSet<Type> referencedTypes, HashSet<Assembly> referencedAssemblies, string projectName)
{
// XamlBuildTask cannot support two different versions of the same dependency in XAML.
// As a workaround, we raise an error here if the workflow contains activities/variables/etc.
// from different versions of the same assembly.
var conflicts =
referencedAssemblies.GroupBy(asm => asm.GetName().Name).Where(grp => grp.Count() > 1).ToList();
if (conflicts.Any())
{
var conflict = conflicts.First();
Assembly asm1 = referencedAssemblies.First(item => item.GetName().Name == conflict.Key);
Assembly asm2 = referencedAssemblies.Last(item => item.GetName().Name == conflict.Key);
var type1 = referencedTypes.First(item => item.Assembly.GetName().Name == asm1.GetName().Name &&
item.Assembly.GetName().Version == asm1.GetName().Version);
var type2 = referencedTypes.First(item => item.Assembly.GetName().Name == asm2.GetName().Name &&
item.Assembly.GetName().Version == asm2.GetName().Version);
string message = string.Format(CompileMessages.MultipleVersionsUsed,
type1.Name, asm1.FullName, type2.Name, asm2.FullName, conflict.Key);
throw new CompileException(message);
}
// Check if the workflow contains a previous version of itself
var referencesToItself = new List<Assembly>(
from assemblies in referencedAssemblies
where assemblies.GetName().Name == projectName
select assemblies);
if (referencesToItself.Any())
{
string message = string.Format(CompileMessages.PreviousSelfVersion,
referencesToItself.First().GetName().Name,
referencesToItself.First().GetName().FullName);
throw new CompileException(message);
}
}
