private static AppDomain BuildChildDomain(AppDomain parentDomain)
{
var evidence = new Evidence(parentDomain.Evidence);
AppDomainSetup setup = parentDomain.SetupInformation;
return AppDomain.CreateDomain("DiscoveryRegion",
evidence, setup);
}
static void Main()
{
// Gets a value indicating whether code must have execution rights in order to execute.
if(!SecurityManager.CheckExecutionRights)
Console.WriteLine("Execution rights are not required to run the assemblies.");
// Gets a value indicating whether code access security is enabled.
if(!SecurityManager.SecurityEnabled)
Console.WriteLine("Security is not enabled.");
// Determines whether the right to control policy has been granted to the caller.
if(SecurityManager.IsGranted(new SecurityPermission(SecurityPermissionFlag.ControlPolicy)))
{
// Define custom named permission sets for Company and Department.
// These will be used for the new code groups.
//CreateCompanyPermission();
//CreateDepartmentPermission();
// Create a parent and child code group at the Machine policy level using the
// permission sets we created.
//CreateCodeGroups();
// Demonstrate the result of a call to ResolvePolicy().
// This is not required for the main thrust of this sample, custom named permissions
// and code groups, but allows demonstration of the ResolvePolicy method.
Console.WriteLine("Current Security Policy:");
Console.WriteLine("------------------------");
DisplaySecurityPolicy();
Console.WriteLine("Resolve Policy demonstration.");
// Get the evidence for the Local Intranet zone.
Evidence intranetZoneEvidence = new Evidence(new object[] { new Zone(SecurityZone.Intranet) }, null);
Console.WriteLine("Show the result of ResolvePolicy for LocalIntranet zone evidence.");
CheckEvidence(intranetZoneEvidence);
// Optionally remove the policy elements that were created.
Console.WriteLine("Would you like to remove the Department code group?");
Console.WriteLine("Please type 'yes' to delete the Department group, else press the Enter key.");
string answer = Console.ReadLine();
if(answer == "yes")
{
DeleteCustomChildCodeGroup("MyDepartment");
SecurityManager.SavePolicy();
}
Console.WriteLine("Would you like to remove all new code groups and permission sets?");
Console.WriteLine("Please type yes to delete all new groups, else press the Enter key.");
answer = Console.ReadLine();
if(answer == "yes")
{
DeleteCustomCodeGroups();
DeleteCustomPermissions();
SecurityManager.SavePolicy();
}
}
else
{
Console.Out.WriteLine("ControlPolicy permission is denied.");
}
return;
}
/// Run the code with less permissions than usual
/// (so it can't read/write to files).
/// This is a false sense of security... the program can still run unmanaged
/// code. But shhh don't worry about that.
static int Main(string[] args)
{
String path = args[0];
PermissionSet ps = new PermissionSet(PermissionState.None);
AppDomainSetup setup = new AppDomainSetup();
Evidence ev = new Evidence();
AppDomain sandbox = AppDomain.CreateDomain("Sandbox",
ev,
setup,
ps);
sandbox.ExecuteAssembly(path);
return 0;
}
public void CompareReviews()
{
const string evidenceRepo = @"C:\Dragon\Evidence\";
var positiveReviews = new Evidence("Positive", evidenceRepo, loadEvidence: true);
var negativeReviews = new Evidence("Negative", evidenceRepo, loadEvidence: true);
var classifier = new Classifier(positiveReviews, negativeReviews);
var reviewUrls = new List<string>();
using (var file = new StreamReader(@"C:\Dragon\RawData\ReviewUrls.txt"))
{
string line;
while ((line = file.ReadLine()) != null)
{
if (string.IsNullOrWhiteSpace(line.Trim())) continue;
reviewUrls.Add(line.Trim());
}
}
var boilerPipeContents = Helper.GetUrlContentsViaBoilerPipe(reviewUrls);
var readabilityContents = Helper.GetUrlContentsViaReadability(reviewUrls);
var uClassifyResults = Helper.GetUClassifyReviewScores(reviewUrls);
var dragonResultsViaReadability = new Dictionary<string, double>();
var dragonResultsViaBoilerPipe = new Dictionary<string, double>();
foreach (var content in boilerPipeContents)
{
var scores = classifier.Classify(content.Value, DragonHelper.DragonHelper.TokenCharMappings, DragonHelper.DragonHelper.ExcludeList);
var positive = scores["Positive"];
dragonResultsViaBoilerPipe.Add(content.Key, positive);
}
foreach (var content in readabilityContents)
{
var scores = classifier.Classify(content.Value, DragonHelper.DragonHelper.TokenCharMappings, DragonHelper.DragonHelper.ExcludeList);
var positive = scores["Positive"];
dragonResultsViaReadability.Add(content.Key, positive);
}
Console.Out.WriteLine("Url,Dragon_Readability,Dragon_BoilerPipe,uClassify");
foreach (var url in reviewUrls)
{
var output = string.Format("{0}, {1}, {2}, {3}", url, dragonResultsViaReadability[url], dragonResultsViaBoilerPipe[url], uClassifyResults[url]);
Console.Out.WriteLine(output);
}
//foreach (var dragonResult in dragonResultsViaReadability)
//{
// var output = string.Format("{0}, {1}, {2}", dragonResult.Key, dragonResult.Value, uClassifyResults[dragonResult.Key]);
// Console.Out.WriteLine(output);
//}
}
public void ClassifyHappyPath()
{
Logger.Debug("Hello");
const string evidenceRepo = @"C:\Dragon\Evidence\";
var positiveReviews = new Evidence("Positive", evidenceRepo, loadEvidence: true);
var negativeReviews = new Evidence("Negative", evidenceRepo, loadEvidence: true);
string testData;
using (var sr = new StreamReader(@"C:\Users\Amrish\Desktop\Review.txt", Encoding.UTF7))
{
testData = sr.ReadToEnd();
}
var classifier = new Classifier(positiveReviews, negativeReviews);
var scores = classifier.Classify(testData, DragonHelper.DragonHelper.TokenCharMappings, DragonHelper.DragonHelper.ExcludeList);
var positive = scores["Positive"];
Assert.IsNotNull(positive);
}
void IConfigManager.Load(string path)
{
try
{
AppDomain current = AppDomain.CurrentDomain;
string name = Path.GetFileNameWithoutExtension(path);
AppDomainSetup info = new AppDomainSetup();
info.ApplicationBase = current.BaseDirectory;
info.ApplicationName = name;
info.DynamicBase = serverPath;
info.CachePath = serverPath;
info.ShadowCopyFiles = "true";
Evidence securityInfo = new Evidence(current.Evidence);
var app = AppDomain.CreateDomain(name, securityInfo, info);
if (app != null)
{
lock (domains)
{
AppDomain old;
if (domains.TryGetValue(path, out old))
{
if (domains.Remove(path))
{
AppDomain.Unload(old);
LogWrapper.Warn("Load.UnloadSuccess:" + path);
}
}
domains.Add(path, app);
string exeFile = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "FrontServer.exe");
app.ExecuteAssembly(exeFile, new string[] { path });
}
LogWrapper.Warn("Load.LoadSuccess:" + path);
}
}
catch (System.Exception ex)
{
LogWrapper.Error("Load.LoadFail", ex);
}
}
public static T GetHostEvidence <T>(this Evidence evidence) where T : EvidenceBase
{
return(evidence.OfType <T>().FirstOrDefault());
}
public bool Check(Evidence evidence)
{
return(false);
}
private static extern Assembly load_with_partial_name(string name, Evidence e);
/// <summary>
/// Pre-loads a test into the correct app domain for the current loader mode.
/// </summary>
/// <param name="test"></param>
/// <param name="paths"></param>
void TestPreLoader_AppDomain(ReliabilityTest test, string[] paths)
{
AppDomain ad = null;
try
{
if (curTestSet.AppDomainLoaderMode != AppDomainLoaderMode.RoundRobin || test.CustomAction == CustomActionType.LegacySecurityPolicy)
{
string appDomainName = AppDomain.CurrentDomain.FriendlyName + "_" + "TestDomain_" + test.Assembly + "_" + Guid.NewGuid().ToString();
logger.WriteToInstrumentationLog(curTestSet, LoggingLevels.AppDomain, "Creating app domain: " + appDomainName + " for " + test.Index.ToString());
AppDomainSetup ads = new AppDomainSetup();
Evidence ev = AppDomain.CurrentDomain.Evidence;
if (test.CustomAction == CustomActionType.LegacySecurityPolicy)
{
ads.SetCompatibilitySwitches(new string[] { "NetFx40_LegacySecurityPolicy" });
ev = new Evidence(new EvidenceBase[] { new Zone(System.Security.SecurityZone.MyComputer) }, null);
}
// Set the probing scope for assemblies to %BVT_ROOT%. The default is %BVT_ROOT%\Stress\CLRCore,
// which causes some tests to fail because their assemblies are out of scope.
ads.ApplicationBase = "file:///" + Environment.GetEnvironmentVariable("BVT_ROOT").Replace(@"\", "/");
ads.PrivateBinPath = "file:///" + Environment.GetEnvironmentVariable("BASE_ROOT").Replace(@"\", "/");
ad = AppDomain.CreateDomain(appDomainName, ev, ads);
}
else
{
ad = _testDomains[test.AppDomainIndex];
}
AssemblyName an = new AssemblyName();
Object ourObj = null;
test.AppDomain = ad;
object obj = ad.CreateInstanceAndUnwrap(Assembly.GetExecutingAssembly().FullName, typeof(LoaderClass).FullName);
LoaderClass lfc = obj as LoaderClass;
if (test.SuppressConsoleOutput)
lfc.SuppressConsole();
if (test.Assembly.ToLower().IndexOf(".exe") == -1 && test.Assembly.ToLower().IndexOf(".dll") == -1) // must be a simple name or fullname...
{
lfc.Load(test.Assembly, paths, this);
}
else // has an executable extension, must be in local directory.
{
lfc.LoadFrom(test.BasePath + test.Assembly, paths, this);
}
// check and see if this test is marked as requiring STA. We only do
// the check once, and then we set the STA/MTA/Unknown bit on the test attributes
// to avoid doing reflection every time we start the test.
if ((test.TestAttrs & TestAttributes.RequiresThread) == TestAttributes.None)
{
ApartmentState state = lfc.CheckMainForThreadType();
switch (state)
{
case ApartmentState.STA:
test.TestAttrs |= TestAttributes.RequiresSTAThread;
break;
case ApartmentState.MTA:
test.TestAttrs |= TestAttributes.RequiresMTAThread;
break;
case ApartmentState.Unknown:
test.TestAttrs |= TestAttributes.RequiresUnknownThread;
break;
}
}
ourObj = lfc.GetTest();
// and now call the register method on the type if it's one of our supported test types.
if (ourObj is ISingleReliabilityTest)
{
((ISingleReliabilityTest)ourObj).Register();
}
else if (ourObj is IMultipleReliabilityTest)
{
((IMultipleReliabilityTest)ourObj).Register();
}
else if (!(ourObj is string)) // we were unable to find a test here - a string is an executable filename.
{
Interlocked.Decrement(ref LoadingCount);
return;
}
test.TestObject = ourObj;
test.MyLoader = lfc;
}
catch (Exception)
{
// if we took an exception while loading the test, but we still have an app domain
// we don't want to leak the app domain.
if (ad != null)
{
test.AppDomain = null;
AppDomain.Unload(ad);
}
throw;
}
}
public ActionResult SaveEvidence(Evidence evidence)
{
new SqlRepository().SaveEvidence(evidence);
return(Content("Evidence Saved"));
}
// Methods
public virtual bool Check(Evidence evidence) {}
public virtual CodeGroup ResolveMatchingCodeGroups(Evidence evidence) {}
public static IEnumerator ResolvePolicyGroups(Evidence evidence)
{
throw new NotSupportedException();
}
public static PermissionSet ResolvePolicy(Evidence evidence, PermissionSet reqdPset, PermissionSet optPset, PermissionSet denyPset, out PermissionSet denied)
{
throw new NotSupportedException();
}
public static PermissionSet ResolveSystemPolicy(Evidence evidence)
{
throw new NotSupportedException();
}
public override CodeGroup ResolveMatchingCodeGroups(Evidence evidence)
{
return(default(CodeGroup));
}
public override PolicyStatement Resolve(Evidence evidence)
{
return(default(PolicyStatement));
}
private static Assembly ReflectionOnlyLoadWithPartialName(string partialName, Evidence securityEvidence)
{
if (securityEvidence != null)
{
new SecurityPermission(SecurityPermissionFlag.ControlEvidence).Demand();
}
AssemblyName fileName = new AssemblyName(partialName);
var assembly = nLoad(fileName, null, securityEvidence, null, null, false, true);
if (assembly != null)
{
return(assembly);
}
var assemblyRef = EnumerateCache(fileName);
if (assemblyRef != null)
{
return(InternalLoad(assemblyRef, securityEvidence, null, true));
}
return(assembly);
}
// Implement the IMembership interface.
public bool Check(Evidence evidence)
{
return true;
}
public PolicyStatement Resolve(Evidence evidence) {}
// private/internal stuff
internal static bool ResolvePolicyLevel(ref PermissionSet ps, PolicyLevel pl, Evidence evidence)
{
throw new NotSupportedException();
}
public override CodeGroup ResolveMatchingCodeGroups (Evidence evidence)
{
if (evidence == null)
throw new ArgumentNullException ("evidence");
throw new NotImplementedException ();
}
internal static void ResolveIdentityPermissions(PermissionSet ps, Evidence evidence)
{
throw new NotSupportedException();
}
public abstract virtual PolicyStatement Resolve(Evidence evidence) {}
internal static Assembly GenerateAssembly(XmlMapping[] xmlMappings, Type[] types, string defaultNamespace, Evidence evidence, CompilerParameters parameters, Assembly assembly, Hashtable assemblies)
{
FileIOPermission.Assert();
for (int i = 0; i < xmlMappings.Length; i++)
{
xmlMappings[i].CheckShallow();
}
Compiler compiler = new Compiler();
try {
Hashtable scopeTable = new Hashtable();
foreach (XmlMapping mapping in xmlMappings)
{
scopeTable[mapping.Scope] = mapping;
}
TypeScope[] scopes = new TypeScope[scopeTable.Keys.Count];
scopeTable.Keys.CopyTo(scopes, 0);
assemblies.Clear();
Hashtable importedTypes = new Hashtable();
foreach (TypeScope scope in scopes)
{
foreach (Type t in scope.Types)
{
compiler.AddImport(t, importedTypes);
Assembly a = t.Assembly;
string name = a.FullName;
if (assemblies[name] != null)
{
continue;
}
if (!a.GlobalAssemblyCache)
{
assemblies[name] = a;
}
}
}
for (int i = 0; i < types.Length; i++)
{
compiler.AddImport(types[i], importedTypes);
}
compiler.AddImport(typeof(object).Assembly);
compiler.AddImport(typeof(XmlSerializer).Assembly);
IndentedWriter writer = new IndentedWriter(compiler.Source, false);
writer.WriteLine("#if _DYNAMIC_XMLSERIALIZER_COMPILATION");
writer.WriteLine("[assembly:System.Security.AllowPartiallyTrustedCallers()]");
writer.WriteLine("[assembly:System.Security.SecurityTransparent()]");
writer.WriteLine("#endif");
// Add AssemblyVersion attribute to match parent accembly version
if (types != null && types.Length > 0 && types[0] != null)
{
writer.WriteLine("[assembly:System.Reflection.AssemblyVersionAttribute(\"" + types[0].Assembly.GetName().Version.ToString() + "\")]");
}
if (assembly != null && types.Length > 0)
{
for (int i = 0; i < types.Length; i++)
{
Type type = types[i];
if (type == null)
{
continue;
}
if (DynamicAssemblies.IsTypeDynamic(type))
{
throw new InvalidOperationException(Res.GetString(Res.XmlPregenTypeDynamic, types[i].FullName));
}
}
writer.Write("[assembly:");
writer.Write(typeof(XmlSerializerVersionAttribute).FullName);
writer.Write("(");
writer.Write("ParentAssemblyId=");
ReflectionAwareCodeGen.WriteQuotedCSharpString(writer, GenerateAssemblyId(types[0]));
writer.Write(", Version=");
ReflectionAwareCodeGen.WriteQuotedCSharpString(writer, ThisAssembly.Version);
if (defaultNamespace != null)
{
writer.Write(", Namespace=");
ReflectionAwareCodeGen.WriteQuotedCSharpString(writer, defaultNamespace);
}
writer.WriteLine(")]");
}
CodeIdentifiers classes = new CodeIdentifiers();
classes.AddUnique("XmlSerializationWriter", "XmlSerializationWriter");
classes.AddUnique("XmlSerializationReader", "XmlSerializationReader");
string suffix = null;
if (types != null && types.Length == 1 && types[0] != null)
{
suffix = CodeIdentifier.MakeValid(types[0].Name);
if (types[0].IsArray)
{
suffix += "Array";
}
}
writer.WriteLine("namespace " + GeneratedAssemblyNamespace + " {");
writer.Indent++;
writer.WriteLine();
string writerClass = "XmlSerializationWriter" + suffix;
writerClass = classes.AddUnique(writerClass, writerClass);
XmlSerializationWriterCodeGen writerCodeGen = new XmlSerializationWriterCodeGen(writer, scopes, "public", writerClass);
writerCodeGen.GenerateBegin();
string[] writeMethodNames = new string[xmlMappings.Length];
for (int i = 0; i < xmlMappings.Length; i++)
{
writeMethodNames[i] = writerCodeGen.GenerateElement(xmlMappings[i]);
}
writerCodeGen.GenerateEnd();
writer.WriteLine();
string readerClass = "XmlSerializationReader" + suffix;
readerClass = classes.AddUnique(readerClass, readerClass);
XmlSerializationReaderCodeGen readerCodeGen = new XmlSerializationReaderCodeGen(writer, scopes, "public", readerClass);
readerCodeGen.GenerateBegin();
string[] readMethodNames = new string[xmlMappings.Length];
for (int i = 0; i < xmlMappings.Length; i++)
{
readMethodNames[i] = readerCodeGen.GenerateElement(xmlMappings[i]);
}
readerCodeGen.GenerateEnd(readMethodNames, xmlMappings, types);
string baseSerializer = readerCodeGen.GenerateBaseSerializer("XmlSerializer1", readerClass, writerClass, classes);
Hashtable serializers = new Hashtable();
for (int i = 0; i < xmlMappings.Length; i++)
{
if (serializers[xmlMappings[i].Key] == null)
{
serializers[xmlMappings[i].Key] = readerCodeGen.GenerateTypedSerializer(readMethodNames[i], writeMethodNames[i], xmlMappings[i], classes, baseSerializer, readerClass, writerClass);
}
}
readerCodeGen.GenerateSerializerContract("XmlSerializerContract", xmlMappings, types, readerClass, readMethodNames, writerClass, writeMethodNames, serializers);
writer.Indent--;
writer.WriteLine("}");
return(compiler.Compile(assembly, defaultNamespace, parameters, evidence));
}
finally {
compiler.Close();
}
}
public override PolicyStatement Resolve(Evidence evidence)
{
return default(PolicyStatement);
}
internal TempAssembly(XmlMapping[] xmlMappings, Type[] types, string defaultNamespace, string location, Evidence evidence)
{
CompilerParameters parameters = new CompilerParameters();
parameters.GenerateInMemory = true;
TempFileCollection tempFiles = new TempFileCollection(location);
parameters.TempFiles = tempFiles;
assembly = GenerateAssembly(xmlMappings, types, defaultNamespace, evidence, parameters, null, assemblies);
#if DEBUG
// use exception in the place of Debug.Assert to avoid throwing asserts from a server process such as aspnet_ewp.exe
if (assembly == null)
{
throw new InvalidOperationException(Res.GetString(Res.XmlInternalErrorDetails, "Failed to generate XmlSerializer assembly, but did not throw"));
}
#endif
InitAssemblyMethods(xmlMappings);
}
public void AddEvidenceDataTest()
{
#region string data
var inputs = new List<string>();
const string input1 = @"Clam’' With's smartphones 21st-century, as with any category of consumer electronics,we
have no choice but to accept compromises. This has been the case throughout the
history of cell phones and it continues to hold true even with best handsets on
the market today. Apple’s () iPhone 5 features #%#5 a class-leading design with
fast, smooth software, but it has a comparatively small @#$@34 display * and lacks some
of the great new functionality we’ve seen intr 29347qi kahg kbreier 8woduced on other,,, platforms in
recent years. The Samsung (005930) Galaxy S III354 is a SLEEK sleek handset with a
stunning screen and a great feature set, but;it feels like9(^*&((^*^T*^*() ^%$&^% a cheap toy,
as does its successor. Nokia’s (NOK) Lumia 920 packs plenty of punch in (^(*&%*z;pe,jpqweqw6e6qw7ec62qe
a sleek package, but it’s thick and heavy, and it is missing a boatload of
top apps. It’s inevitable — some level of compromise is inherent in all smartphones.";
var custom = AmazonEvidenceParser.ExtractReviews(ConfigurationManager.AppSettings["CustomReviewData1"], Mood.NEUTRAL).ToList();
inputs.Add(input1);
inputs.AddRange(custom);
//inputs.Add(input);
#endregion string data
foreach (var input in inputs)
{
var evidence = new Evidence("DragonClassifier.Tests.EvidenceTests", ConfigurationManager.AppSettings["EvidenceRepository"]);
evidence.AddEvidenceData(input, DragonHelper.DragonHelper.ExcludeList);
var evidenceData = evidence.GetEvidence();
var evidenceKeys = evidenceData.Keys.ToList();
evidenceKeys.Sort();
var parsedInput = Regex.Replace(input, "[^a-zA-Z]+", " ");
foreach (var key in evidenceKeys)
{
var expectedKey = key;
var regexMatch = @"\b" + expectedKey + @"\b";
var regex = new Regex(regexMatch, RegexOptions.IgnoreCase);
var expectedCount = regex.Matches(parsedInput).Count;
var actualCount = evidenceData[key];
parsedInput = regex.Replace(parsedInput, string.Empty);
Assert.AreEqual(expectedCount, actualCount);
}
parsedInput =
DragonHelper.DragonHelper.ExcludeList.Select(exclude => @"\b" + exclude + @"\b")
.Select(regexMatch => new Regex(regexMatch, RegexOptions.IgnoreCase))
.Aggregate(parsedInput, (current, regex) => regex.Replace(current, string.Empty));
Assert.AreEqual(parsedInput.Trim(), string.Empty);
Thread.Sleep(1000);
evidence.PersistEvidence(false);
var evidenceLoaded = new Evidence("DragonClassifier.Tests.EvidenceTests", ConfigurationManager.AppSettings["EvidenceRepository"], true);
var evidenceLoadedData = evidenceLoaded.GetEvidence();
var evidenceLoadedKeys = evidenceLoadedData.Keys.ToList();
evidenceLoadedKeys.Sort();
foreach (var key in evidenceLoadedKeys)
{
Assert.AreEqual(evidenceData[key], evidenceLoadedData[key]);
}
}
}
internal static bool ResolvePolicyLevel(ref PermissionSet ps, PolicyLevel pl, Evidence evidence)
{
PolicyStatement pst = pl.Resolve(evidence);
if (pst != null)
{
if (ps == null)
{
// only for initial (first) policy level processed
ps = pst.PermissionSet;
}
else
{
ps = ps.Intersect(pst.PermissionSet);
if (ps == null)
{
// null is equals to None - exist that null can throw NullReferenceException ;-)
ps = new PermissionSet(PermissionState.None);
}
}
if ((pst.Attributes & PolicyStatementAttribute.LevelFinal) == PolicyStatementAttribute.LevelFinal)
{
return(true);
}
}
return(false);
}
public static Assembly LoadWithPartialName(string partialName, Evidence securityEvidence)
{
return(LoadWithPartialName(partialName, securityEvidence, true));
}
public XmlSerializer(Type type, XmlAttributeOverrides overrides, Type[] extraTypes, XmlRootAttribute root, string defaultNamespace, string location, Evidence evidence)
{
}
public static void AddHostEvidence(this Evidence evidence, EvidenceBase hostEvidence)
{
evidence.AddHost(hostEvidence);
}
public static XmlSerializer[] FromMappings(XmlMapping[] mappings, Evidence evidence)
{
throw new NotImplementedException();
}
/// <summary>
/// Invokes a Sequence object for the given MEI element
/// </summary>
/// <param name="_sequence">Sequence</param>
/// <param name="layerElement">MEI Element to process</param>
internal static ObjectInSequence InvokeSequenceObject(Sequence _sequence, MeiElement layerElement, Evidence evidence = Evidence.Clear, int ligaturePos = 0, string ligForm = null)
{
ObjectInSequence obj = null;
if (layerElement is mei.Note note)
{
obj = new Model.Note();
NoteConverter.ConvertNote((Model.Note)obj, note);
//check for @lig attribute
if (note.HasLig())
{
ligForm = note.GetLigValue();
}
TinyConverters.LigatureHandler((Model.Note)obj, ligaturePos, ligForm);
}
// Ligatures needs to be be handled recursively to get their elements and store related data
else if (layerElement is mei.Ligature ligature)
{
foreach (MeiElement ligaturChild in ligature.Elements())
{
ligaturePos++;
InvokeSequenceObject(_sequence, ligaturChild, evidence, ligaturePos, ligature.GetFormValue());
}
ligaturePos = 0;
}
else if (layerElement is mei.Rest)
{
obj = new Model.Rest();
RestConverter.ConvertRest((Model.Rest)obj, (mei.Rest)layerElement);
}
else if (layerElement is Chord)
{
// We need a List of all objects in the Chord to add them to the sequence at the same position
List <ObjectInSequence> lstChordEvents = new List <ObjectInSequence>();
foreach (MeiElement noteRest in layerElement.Descendants())
{
ObjectInSequence objNoteRest = InvokeSequenceObject(null, noteRest);
if (objNoteRest != null)
{
lstChordEvents.Add(objNoteRest);
}
}
_sequence?.AddToSequence(lstChordEvents.ToArray());
}
else if (layerElement is mei.KeySig)
{
// We need a List of all KeyAccids in the KeySig to add them to the sequence at the same position
List <ObjectInSequence> lstAcids = new List <ObjectInSequence>();
foreach (KeyAccid keyAccid in layerElement.Elements())
{
lstAcids.Add(InvokeSequenceObject(null, keyAccid));
}
_sequence?.AddToSequence(lstAcids.ToArray());
}
else if (layerElement is KeyAccid)
{
obj = new Model.KeyAccidental();
AccidentalConverter.ConvertKeyAccidental((Model.KeyAccidental)obj, (mei.KeyAccid)layerElement);
}
else if (layerElement is mei.Accid)
{
obj = new Model.Accidental();
AccidentalConverter.ConvertAccidental((Model.Accidental)obj, (mei.Accid)layerElement);
}
else if (layerElement is mei.Mensur)
{
obj = new Model.Mensur();
MensurProportionConverter.ConvertMensur((Model.Mensur)obj, (mei.Mensur)layerElement);
}
else if (layerElement is mei.Proport)
{
obj = new Model.Proportion();
MensurProportionConverter.ConvertProportion((Model.Proportion)obj, (mei.Proport)layerElement);
}
else if (layerElement is mei.BarLine)
{
obj = new Model.Barline();
TinyConverters.ConvertBarline((Model.Barline)obj, (mei.BarLine)layerElement);
}
else if (layerElement is mei.Dot)
{
obj = new Model.Dot();
}
else if (layerElement is mei.Clef)
{
obj = new Model.Clef();
TinyConverters.ConvertClef((Model.Clef)obj, (mei.Clef)layerElement);
}
else if (layerElement is mei.Custos)
{
obj = new Model.Custos();
TinyConverters.ConvertCustos((Model.Custos)obj, (mei.Custos)layerElement);
}
else if (layerElement is mei.Unclear || layerElement is mei.Supplied)
{
Evidence evd = TinyConverters.GetEvidence(layerElement);
foreach (MeiElement evdChild in layerElement.Elements())
{
InvokeSequenceObject(_sequence, evdChild, evd);
}
}
else if (layerElement is mei.Damage || layerElement is mei.Gap)
{
obj = new Model.Gap();
TinyConverters.ConvertGap((Model.Gap)obj, layerElement);
}
if (obj != null)
{
//After type definition, add ID of MEI element
obj.ID = layerElement.GetId();
//Set Evidence
obj.Evidence = evidence;
//Add to sequence if defined
_sequence?.AddToSequence(obj);
}
return(obj);
}
public IPermission CreateIdentityPermission(Evidence evidence)
{
return(new FileIOPermission(FileIOPermissionAccess.Read, uncDir));
}
public void Merge(Evidence evidence) {}
public XmlSecureResolver(XmlResolver resolver, Evidence evidence) : this(resolver, SecurityManager.GetStandardSandbox(evidence))
{
}
// Methods
public virtual PolicyStatement Resolve(Evidence evidence) {}
public XmlSecureResolver(XmlResolver resolver, Evidence evidence) : this(resolver, (PermissionSet)null)
{
}
public override PolicyStatement Resolve (Evidence evidence)
{
if (evidence == null)
throw new ArgumentNullException ("evidence");
throw new NotImplementedException ();
}
public override ApplicationTrust DetermineApplicationTrust(Evidence applicationEvidence, Evidence activatorEvidence, TrustManagerContext context)
{
EventTrace.EasyTraceEvent(EventTrace.Keyword.KeywordPerf | EventTrace.Keyword.KeywordHosting, EventTrace.Level.Verbose, EventTrace.Event.WpfHost_DetermineApplicationTrustStart);
Uri uriFromActivationData = this.GetUriFromActivationData(0);
bool flag = PresentationAppDomainManager.IsDebug || this.GetBoolFromActivationData(1);
BrowserInteropHelper.SetBrowserHosted(true);
ApplicationTrust applicationTrust;
if (flag)
{
context.IgnorePersistedDecision = true;
context.Persist = false;
context.KeepAlive = false;
context.NoPrompt = true;
applicationTrust = base.DetermineApplicationTrust(applicationEvidence, activatorEvidence, context);
}
else
{
Zone hostEvidence = applicationEvidence.GetHostEvidence <Zone>();
context.NoPrompt = (hostEvidence.SecurityZone != SecurityZone.Intranet && hostEvidence.SecurityZone != SecurityZone.Trusted);
bool flag2 = !context.NoPrompt && PresentationHostSecurityManager.ElevationPromptOwnerWindow != IntPtr.Zero;
if (flag2)
{
IntPtr ancestor = UnsafeNativeMethods.GetAncestor(new HandleRef(null, PresentationHostSecurityManager.ElevationPromptOwnerWindow), 2);
PresentationHostSecurityManager.SetFakeActiveWindow(ancestor);
PresentationHostSecurityManager.ElevationPromptOwnerWindow = IntPtr.Zero;
}
try
{
applicationTrust = base.DetermineApplicationTrust(applicationEvidence, activatorEvidence, context);
}
finally
{
if (flag2)
{
PresentationHostSecurityManager.SetFakeActiveWindow((IntPtr)0);
}
}
}
if (applicationTrust != null)
{
PermissionSet permissionSet = applicationTrust.DefaultGrantSet.PermissionSet;
if (flag)
{
Uri uriFromActivationData2 = this.GetUriFromActivationData(2);
if (uriFromActivationData2 != null)
{
permissionSet = PresentationHostSecurityManager.AddPermissionForUri(permissionSet, uriFromActivationData2);
}
}
if (permissionSet is ReadOnlyPermissionSet)
{
permissionSet = new PermissionSet(permissionSet);
}
applicationTrust.DefaultGrantSet.PermissionSet = permissionSet;
}
EventTrace.EasyTraceEvent(EventTrace.Keyword.KeywordPerf | EventTrace.Keyword.KeywordHosting, EventTrace.Level.Verbose, EventTrace.Event.WpfHost_DetermineApplicationTrustEnd);
return(applicationTrust);
}
public IPermission CreateIdentityPermission(Evidence evidence) { return default(IPermission); }
// Demonstrate the use of ResolvePolicy.
private static void CheckEvidence(Evidence evidence)
{
// Display the code groups to which the evidence belongs.
Console.WriteLine("ResolvePolicy for the given evidence.");
Console.WriteLine("Current evidence belongs to the following code groups:");
IEnumerator policyEnumerator = SecurityManager.PolicyHierarchy();
while(policyEnumerator.MoveNext())
{
PolicyLevel currentLevel = (PolicyLevel)policyEnumerator.Current;
CodeGroup cg1 = currentLevel.ResolveMatchingCodeGroups(evidence);
Console.WriteLine(currentLevel.Label + " Level" );
Console.WriteLine("\tCodeGroup = " + cg1.Name);
Console.WriteLine("StoreLocation = " + currentLevel.StoreLocation);
IEnumerator cgE1 = cg1.Children.GetEnumerator();
while(cgE1.MoveNext())
{
Console.WriteLine("\t\tGroup = " + ((CodeGroup)cgE1.Current).Name);
}
}
// Show how ResolvePolicy is used to determine the set of permissions that would be granted
// by the security system to code, based on the evidence and the permission sets requested.
// The permission sets require Execute permission; allow optional Read access permission
// to C:\temp; and deny the code permission to control security policy.
Console.WriteLine("\nCreate permission sets requiring Execute permission, requesting optional " +
"\nRead permission for 'C:\\temp', and dening permission to control policy.");
PermissionSet requiredSet = new PermissionSet(PermissionState.None);
requiredSet.AddPermission(new SecurityPermission(SecurityPermissionFlag.Execution));
PermissionSet optionalSet = new PermissionSet(PermissionState.None);
optionalSet.AddPermission(new FileIOPermission(FileIOPermissionAccess.Read, new string[] { @"c:\temp" }));
PermissionSet deniedSet = new PermissionSet(PermissionState.None);
deniedSet.AddPermission(new SecurityPermission(SecurityPermissionFlag.ControlPolicy));
// Show the granted permissions.
Console.WriteLine("\nCurrent permissions granted:");
PermissionSet permsDenied = null;
foreach(IPermission perm in SecurityManager.ResolvePolicy(evidence, requiredSet, optionalSet, deniedSet, out permsDenied))
Console.WriteLine(perm.ToXml().ToString());
// Show the denied permissions.
Console.WriteLine("Current permissions denied:");
foreach(IPermission perm in permsDenied)
Console.WriteLine(perm.ToXml().ToString());
return;
}
// Methods
public virtual System.Security.IPermission CreateIdentityPermission(Evidence evidence)
{
}
//[TestMethod]
public void GenerateAmazonEvidence()
{
//Empty brazes to call the desructor of Evidence class
{
const string evidenceRepo = @"C:\Dragon\Evidence\";
var positiveReviews = new Evidence("Positive", evidenceRepo, loadEvidence: false, saveEvidence: true);
var negativeReviews = new Evidence("Negative", evidenceRepo, loadEvidence: false, saveEvidence: true);
positiveReviews.AddEvidenceData(AmazonEvidenceParser.GetPositiveReviews(), DragonHelper.DragonHelper.ExcludeList);
negativeReviews.AddEvidenceData(AmazonEvidenceParser.GetNegativeReviews(), DragonHelper.DragonHelper.ExcludeList);
}
}
// -rsp assemblyname
// -resolveperm assemblyname
static bool ResolvePermissions(string assemblyname)
{
Evidence ev = GetAssemblyEvidences(assemblyname);
if (ev == null)
{
return(false);
}
PermissionSet ps = null;
Console.WriteLine();
if (policyLevelDefault)
{
// different "default" here
IEnumerator e = SecurityManager.PolicyHierarchy();
while (e.MoveNext())
{
PolicyLevel pl = (PolicyLevel)e.Current;
Console.WriteLine("Resolving {0} level", pl.Label);
if (ps == null)
{
ps = pl.Resolve(ev).PermissionSet;
}
else
{
ps = ps.Intersect(pl.Resolve(ev).PermissionSet);
}
}
}
else
{
// use the user specified levels
foreach (PolicyLevel pl in Levels)
{
Console.WriteLine("Resolving {0} level", pl.Label);
if (ps == null)
{
ps = pl.Resolve(ev).PermissionSet;
}
else
{
ps = ps.Intersect(pl.Resolve(ev).PermissionSet);
}
}
}
if (ps == null)
{
return(false);
}
IEnumerator ee = ev.GetHostEnumerator();
while (ee.MoveNext())
{
IIdentityPermissionFactory ipf = (ee.Current as IIdentityPermissionFactory);
if (ipf != null)
{
IPermission p = ipf.CreateIdentityPermission(ev);
ps.AddPermission(p);
}
}
Console.WriteLine("{0}Grant:{0}{1}", Environment.NewLine, ps.ToXml().ToString());
return(true);
}
public Evidence(Evidence evidence) {}
public bool Check(Evidence evidence) { return false; }
public bool Check(Evidence evidence)
{
return(true);
}
// FIXME: What are we missing?
public static Assembly LoadFrom(String assemblyFile, Evidence securityEvidence, byte[] hashValue, AssemblyHashAlgorithm hashAlgorithm)
{
throw new NotImplementedException();
}
public static Assembly Load(String assemblyString, Evidence assemblySecurity)
{
return(AppDomain.CurrentDomain.Load(assemblyString, assemblySecurity));
}
//[TestMethod]
public void ExtractContentsAndClassify()
{
const string evidenceRepo = @"C:\Dragon\Evidence\";
var positiveReviews = new Evidence("Positive", evidenceRepo, loadEvidence: true);
var negativeReviews = new Evidence("Negative", evidenceRepo, loadEvidence: true);
var classifier = new Classifier(positiveReviews, negativeReviews);
const string reviewUrl = "http://www.theverge.com/2012/9/30/3433110/amazon-kindle-paperwhite-review";
var extractedContent = Helper.GetUrlContentsViaReadability(reviewUrl);
var scores = classifier.Classify(extractedContent, DragonHelper.DragonHelper.TokenCharMappings, DragonHelper.DragonHelper.ExcludeList);
var positiveFromUrl = scores["Positive"];
Assert.IsNotNull(positiveFromUrl);
string testData;
using (var sr = new StreamReader(@"C:\Users\Amrish\Desktop\Review.txt", Encoding.UTF7))
{
testData = sr.ReadToEnd();
}
scores = classifier.Classify(testData, DragonHelper.DragonHelper.TokenCharMappings, DragonHelper.DragonHelper.ExcludeList);
var positiveFromContents = scores["Positive"];
Assert.IsNotNull(positiveFromContents);
}
public static Assembly Load(AssemblyName assemblyRef, Evidence assemblySecurity)
{
return(AppDomain.CurrentDomain.Load(assemblyRef, assemblySecurity));
}
public override CodeGroup ResolveMatchingCodeGroups(Evidence evidence)
{
return default(CodeGroup);
}
public static Assembly Load(Byte[] rawAssembly, Byte[] rawSymbolStore,
Evidence securityEvidence)
{
return(AppDomain.CurrentDomain.Load(rawAssembly, rawSymbolStore, securityEvidence));
}
//--------spusteni hry, kliknuti na tlacitko Start
private void Start_button1_Click(object sender, EventArgs e)
{
StartPanel2.Visible = false;
pictureBox1.Visible = true;
evidence = new Evidence(sirka, vyska);
pocetLidiCislo_label.Text = "0";
evidence.mapaAtrakciAChodniku = new Mapa(sirka, vyska);
VytvorMapu(sirka, vyska);
HraciPanel.Visible = true;
timerLide.Enabled = true;
timerAtrakce.Enabled = true;
}
public static int Main(string[] args){
AppDomainSetup setup = new AppDomainSetup();
// fusion settings
setup.PrivateBinPath = "";
setup.PrivateBinPathProbe = "*"; // disable loading from app base
try {
AppDomain appDomain = null;
Evidence evidence = new Evidence(AppDomain.CurrentDomain.Evidence);
appDomain = AppDomain.CreateDomain("Compiler", evidence, setup);
JScriptCompiler jsc = (JScriptCompiler)(appDomain.CreateInstance(
Assembly.GetAssembly(typeof(JScriptCompiler)).FullName, "JScriptCompiler").Unwrap());
return jsc.Run(args);
}
catch (Exception e) {
Console.WriteLine(JScriptCompiler.Localize("INTERNAL COMPILER ERROR", e.Message));
return 10;
}
catch {
Console.WriteLine(JScriptCompiler.Localize("INTERNAL COMPILER ERROR"));
return 10;
}
}
