public override void HandleRequest(IRequestContext ctx) { string v; if (!ctx.UrlVariables.TryGetValue(RcParam, out v)) { v = ctx.QueryString[RcParam]; } if (v == null || v.Length == 0) { v = "index.htm"; } string rc = ResourcePrefix + "." + v; log.Debug("Servlet {0} trying to load {1}", MatchUrl, rc); ctx.ResponseContentType = MimeTypes.GetMimeTypeForExtension(Path.GetExtension(v)); using (Stream stm = SourceAssembly.GetManifestResourceStream(ResourcePrefix + "." + v)) { if (stm == null) { throw new NotFoundException(); } CopyStream(stm, ctx.OutputStream); } }
public void DeduplicatesReferencedAssemblies() { var assembly1a = new SourceAssembly( QualifiedName("1"), version: new Version(1, 0, 0), ImmutableArray <IAssembly> .Empty, ImmutableArray <IDocument> .Empty, new MockAssemblyCompiler()); var assembly1b = new SourceAssembly( QualifiedName("1"), version: new Version(1, 0, 0), ImmutableArray <IAssembly> .Empty, ImmutableArray <IDocument> .Empty, new MockAssemblyCompiler()); var assembly2 = new SourceAssembly( QualifiedName("2"), version: new Version(1, 0, 0), ImmutableArray.Create <IAssembly>(assembly1a), ImmutableArray <IDocument> .Empty, new MockAssemblyCompiler()); var assembly3 = new SourceAssembly( QualifiedName("3"), version: new Version(1, 0, 0), ImmutableArray.Create <IAssembly>(assembly1b), ImmutableArray <IDocument> .Empty, new MockAssemblyCompiler()); var assembly = (IAssembly) new SourceAssembly( QualifiedName("TestAssembly"), version: new Version(1, 0, 0), ImmutableArray.Create <IAssembly>(assembly2, assembly3), ImmutableArray <IDocument> .Empty, new MockAssemblyCompiler()); Assert.Equal(new[] { assembly1a, assembly2, assembly3, assembly }, assembly.ReferencedAssembliesAndSelf); }
private Assembly LoadThemePartAssembly() { try { var stream = SourceAssembly.GetResourceStream(ZipUri); using var archive = new ZipArchive(stream); foreach (var entry in archive.Entries) { if (!entry.Name.EndsWith(".dll", StringComparison.OrdinalIgnoreCase)) { continue; } using var entryStream = entry.Open(); using var ms = new MemoryStream(); entryStream.CopyTo(ms); return(Assembly.Load(ms.ToArray())); } return(null); } catch (Exception e) { LogService.LogError(e); return(null); } }
public void CanReadDependencies() { var dep1Name = "a1"; var dep2Name = "a2"; var dep1Version = new Version(1, 2, 3); var dep2Version = new Version(4, 5, 6, "alpha1"); var dep1 = new SourceAssembly( QualifiedName(dep1Name), dep1Version, ImmutableArray <IAssembly> .Empty, ImmutableArray <IDocument> .Empty, _assemblyCompiler); var dep2 = new SourceAssembly( QualifiedName(dep2Name), dep2Version, ImmutableArray <IAssembly> .Empty, ImmutableArray <IDocument> .Empty, _assemblyCompiler); var assembly = new SourceAssembly( QualifiedName("a"), new Version(0, 0, 0), ImmutableArray.Create <IAssembly>(dep1, dep2), ImmutableArray <IDocument> .Empty, _assemblyCompiler); assembly.VerifyDiagnostics().VerifyEmit( testEmittedAssembly: (_, a, _1) => Assert.Equal(new[] { new Dependency(dep1Name, dep1Version.ToString()), new Dependency(dep2Name, dep2Version.ToString()) }, new DependencyAttributeReader().ReadDependencies(a))); }
/// <summary> /// Initializes a new instance of the <see cref="ZpCodedException"/> class. /// </summary> /// <param name="aSourceAssembly">A source assembly.</param> /// <param name="aMessage">A message.</param> /// <param name="aMessageCode">A message code.</param> /// <param name="aMethodCode">A method code.</param> /// <param name="aObjectCode">A object code.</param> /// <param name="aInnerException">A inner exception.</param> public ZpCodedException(SourceAssembly aSourceAssembly, string aMessage, string aMessageCode, string aMethodCode, string aObjectCode, Exception aInnerException) : base(aMessage, aInnerException) { _sourceAssembly = aSourceAssembly; _messageCode = aMessageCode; _methodCode = aMethodCode; _objectCode = aObjectCode; }
/// <summary> /// This method loads all the relationship type that this entity takes part in /// </summary> private void LoadRelationshipTypes() { foreach ( EdmRelationshipAttribute roleAttribute in SourceAssembly.GetCustomAttributes(typeof(EdmRelationshipAttribute), false /*inherit*/)) { // Check if there is an entry already with this name if (TryFindNullParametersInRelationshipAttribute(roleAttribute)) { // don't give more errors for these same bad parameters continue; } var errorEncountered = false; // return error if the role names are the same if (roleAttribute.Role1Name == roleAttribute.Role2Name) { SessionData.EdmItemErrors.Add( new EdmItemError( Strings.SameRoleNameOnRelationshipAttribute(roleAttribute.RelationshipName, roleAttribute.Role2Name))); errorEncountered = true; } if (!errorEncountered) { var associationType = new AssociationType( roleAttribute.RelationshipName, roleAttribute.RelationshipNamespaceName, roleAttribute.IsForeignKey, DataSpace.OSpace); SessionData.TypesInLoading.Add(associationType.FullName, associationType); TrackClosure(roleAttribute.Role1Type); TrackClosure(roleAttribute.Role2Type); // prevent lifting of loop vars var r1Name = roleAttribute.Role1Name; var r1Type = roleAttribute.Role1Type; var r1Multiplicity = roleAttribute.Role1Multiplicity; AddTypeResolver( () => ResolveAssociationEnd(associationType, r1Name, r1Type, r1Multiplicity)); // prevent lifting of loop vars var r2Name = roleAttribute.Role2Name; var r2Type = roleAttribute.Role2Type; var r2Multiplicity = roleAttribute.Role2Multiplicity; AddTypeResolver( () => ResolveAssociationEnd(associationType, r2Name, r2Type, r2Multiplicity)); // get assembly entry and add association type to the list of types in the assembly Debug.Assert( !CacheEntry.ContainsType(associationType.FullName), "Relationship type must not be present in the list of types"); CacheEntry.TypesInAssembly.Add(associationType); } } }
private string[] ExtractSourceAssemblies() { List <string> srcAssemblies = new List <string>(); if (AdditionalSourceAssemblies != null) { srcAssemblies.AddRange(AdditionalSourceAssemblies.Select(c => c.ItemSpec)); } if (SourceAssembly != null) { srcAssemblies.AddRange(SourceAssembly.Select(c => Path.Combine(ProjectRoot, c.ItemSpec))); } return(srcAssemblies.ToArray()); }
/// <summary> /// Initializes a new instance of the <see cref="ZpCodedException"/> class. /// </summary> /// <param name="info">The <see cref="T:System.Runtime.Serialization.SerializationInfo"/> that holds the serialized object data about the exception being thrown.</param> /// <param name="context">The <see cref="T:System.Runtime.Serialization.StreamingContext"/> that contains contextual information about the source or destination.</param> /// <exception cref="T:System.ArgumentNullException">The <paramref name="info"/> parameter is null. </exception> /// <exception cref="T:System.Runtime.Serialization.SerializationException">The class name is null or <see cref="P:System.Exception.HResult"/> is zero (0). </exception> protected ZpCodedException(SerializationInfo info, StreamingContext context) : base(info, context) { if (info == null) { return; } _sourceAssembly = (SourceAssembly)info.GetInt32("_sourceAssembly"); _messageCode = info.GetString("_messageCode"); _methodCode = info.GetString("_methodCode"); _objectCode = info.GetString("_objectCode"); _messagePairList = (List <MessagePair>)info.GetValue("_messagePairList", typeof(List <MessagePair>)); }
protected override void LoadTypesFromAssembly() { foreach (var type in SourceAssembly.GetAccessibleTypes()) { EdmType cspaceType; if (TryGetCSpaceTypeMatch(type, out cspaceType)) { if (type.IsValueType && !type.IsEnum) { SessionData.LoadMessageLogger.LogLoadMessage( Strings.Validator_OSpace_Convention_Struct(cspaceType.FullName, type.FullName), cspaceType); continue; } EdmType ospaceType; if (TryCreateType(type, cspaceType, out ospaceType)) { Debug.Assert( ospaceType is StructuralType || Helper.IsEnumType(ospaceType), "Only StructuralType or EnumType expected."); CacheEntry.TypesInAssembly.Add(ospaceType); // check for duplicates so we don't cause an ArgumentException, // Mapping will do the actual error for the duplicate type later if (!SessionData.CspaceToOspace.ContainsKey(cspaceType)) { SessionData.CspaceToOspace.Add(cspaceType, ospaceType); } else { // at this point there is already a Clr Type that is structurally matched to this CSpace type, we throw exception var previousOSpaceType = SessionData.CspaceToOspace[cspaceType]; SessionData.EdmItemErrors.Add( new EdmItemError( Strings.Validator_OSpace_Convention_AmbiguousClrType( cspaceType.Name, previousOSpaceType.ClrType.FullName, type.FullName))); } } } } if (SessionData.TypesInLoading.Count == 0) { Debug.Assert(CacheEntry.ClosureAssemblies.Count == 0, "How did we get closure assemblies?"); // since we didn't find any types, don't lock into convention based SessionData.ObjectItemAssemblyLoaderFactory = null; } }
/// <summary> /// Assigns the fields and properties of aSource to this instance. /// </summary> /// <param name="aSource">A source TransactionStatus.</param> public void AssignFromSource(TransactionStatus aSource) { if (aSource == null) { return; } _transactionResult = aSource._transactionResult; _sourceAssembly = aSource._sourceAssembly; _targetUrl = aSource._targetUrl; _message = aSource._message; _innerMessage = aSource._innerMessage; aSource._messagePairList.ForEach(vSourceMessagePair => { var vTargetMessagePair = new MessagePair(vSourceMessagePair.Message, vSourceMessagePair.Subject); _messagePairList.Add(vTargetMessagePair); }); }
// <summary> // Loads the set of types from the given assembly and adds it to the given list of types // </summary> protected override void LoadTypesFromAssembly() { Debug.Assert(CacheEntry.TypesInAssembly.Count == 0); LoadRelationshipTypes(); // Loop through each type in the assembly and process it foreach (var type in SourceAssembly.GetAccessibleTypes()) { // If the type doesn't have the same EdmTypeAttribute defined, then it's not a special type // that we care about, skip it. if (!type.GetCustomAttributes <EdmTypeAttribute>(inherit: false).Any()) { continue; } // Generic type is not supported, if the user attributed this generic type using EdmTypeAttribute, // then the exception message can help them better understand what is going on instead of just // failing at a much later point of OC type mapping lookup with a super generic error message if (type.IsGenericType()) { SessionData.EdmItemErrors.Add(new EdmItemError(Strings.GenericTypeNotSupported(type.FullName))); continue; } // Load the metadata for this type LoadType(type); } if (_referenceResolutions.Count != 0) { SessionData.RegisterForLevel1PostSessionProcessing(this); } if (_unresolvedNavigationProperties.Count != 0) { SessionData.RegisterForLevel2PostSessionProcessing(this); } }
public void ErrorsIfReferencedAssembliesContainDifferentVersionOfSameAssembly() { var assembly1a = new SourceAssembly( QualifiedName("1"), version: new Version(1, 0, 0), ImmutableArray <IAssembly> .Empty, ImmutableArray <IDocument> .Empty, new MockAssemblyCompiler()); var assembly1b = new SourceAssembly( QualifiedName("1"), version: new Version(1, 0, 1), ImmutableArray <IAssembly> .Empty, ImmutableArray <IDocument> .Empty, new MockAssemblyCompiler()); new SourceAssembly( QualifiedName("TestAssembly"), version: new Version(1, 0, 0), ImmutableArray.Create <IAssembly>(assembly1a, assembly1b), ImmutableArray <IDocument> .Empty, new MockAssemblyCompiler()).VerifyDiagnostics( new Diagnostic(new Location(new TextToken(@"")), ErrorCode.MultipleVersionsOfSameAssembly)); }
/// <summary> /// Initializes a new instance of the <see cref="ZpCodedException"/> class. /// </summary> /// <param name="info">The <see cref="T:System.Runtime.Serialization.SerializationInfo"/> that holds the serialized object data about the exception being thrown.</param> /// <param name="context">The <see cref="T:System.Runtime.Serialization.StreamingContext"/> that contains contextual information about the source or destination.</param> /// <exception cref="T:System.ArgumentNullException">The <paramref name="info"/> parameter is null. </exception> /// <exception cref="T:System.Runtime.Serialization.SerializationException">The class name is null or <see cref="P:System.Exception.HResult"/> is zero (0). </exception> protected ZpCodedException(SerializationInfo info, StreamingContext context) : base(info, context) { if (info == null) return; _sourceAssembly = (SourceAssembly)info.GetInt32("_sourceAssembly"); _messageCode = info.GetString("_messageCode"); _methodCode = info.GetString("_methodCode"); _objectCode = info.GetString("_objectCode"); _messagePairList = (List<MessagePair>)info.GetValue("_messagePairList", typeof(List<MessagePair>)); }