/// <summary>
        /// Parses the specified token.
        /// </summary>
        /// <param name="token">The token.</param>
        /// <param name="parent">The parent schema.</param>
        /// <param name="namedSchemas">The schemas.</param>
        /// <returns>
        /// Schema internal representation.
        /// </returns>
        /// <exception cref="System.Runtime.Serialization.SerializationException">Thrown when JSON schema type is not supported.</exception>
        private TypeSchema Parse(JToken token, NamedSchema parent, Dictionary <string, NamedSchema> namedSchemas)
        {
            if (token.Type == JTokenType.Object)
            {
                return(this.ParseJsonObject(token as JObject, parent, namedSchemas));
            }

            if (token.Type == JTokenType.String)
            {
                var t = (string)token;
                if (namedSchemas.ContainsKey(t))
                {
                    return(namedSchemas[t]);
                }

                if (parent != null && namedSchemas.ContainsKey(parent.Namespace + "." + t))
                {
                    return(namedSchemas[parent.Namespace + "." + t]);
                }

                // Primitive.
                return(this.ParsePrimitiveTypeFromString(t));
            }

            if (token.Type == JTokenType.Array)
            {
                return(this.ParseUnionType(token as JArray, parent, namedSchemas));
            }

            throw new SerializationException(
                      string.Format(CultureInfo.InvariantCulture, "Unexpected Json schema type '{0}'.", token));
        }
        /// <summary>
        /// Parses the record type.
        /// </summary>
        /// <param name="record">The record.</param>
        /// <param name="parent">The parent schema.</param>
        /// <param name="namedSchemas">The named schemas.</param>
        /// <returns>
        /// Schema internal representation.
        /// </returns>
        /// <exception cref="System.Runtime.Serialization.SerializationException">Thrown when <paramref name="record"/> can not be parsed properly.</exception>
        private TypeSchema ParseRecordType(JObject record, NamedSchema parent, Dictionary <string, NamedSchema> namedSchemas)
        {
            var name       = record.RequiredProperty <string>(Token.Name);
            var nspace     = this.GetNamespace(record, parent, name);
            var recordName = new SchemaName(name, nspace);

            var doc        = record.OptionalProperty <string>(Token.Doc);
            var aliases    = this.GetAliases(record, recordName.Namespace);
            var attributes = new NamedEntityAttributes(recordName, aliases, doc);

            Dictionary <string, string> customAttributes = record.GetAttributesNotIn(StandardProperties.Record);
            var result = new RecordSchema(attributes, typeof(AvroRecord), customAttributes);

            namedSchemas.Add(result.FullName, result);

            List <RecordField> fields = record.OptionalArrayProperty(
                Token.Fields,
                (field, index) =>
            {
                if (field.Type != JTokenType.Object)
                {
                    throw new SerializationException(
                        string.Format(CultureInfo.InvariantCulture, "Property 'fields' has invalid value '{0}'.", field));
                }
                return(this.ParseRecordField(field as JObject, result, namedSchemas, index));
            });

            fields.ForEach(result.AddField);
            return(result);
        }
        /// <summary>
        /// Parses a JSON object representing an Avro enumeration to a <see cref="EnumSchema"/>.
        /// </summary>
        /// <param name="enumeration">The JSON token that represents the enumeration.</param>
        /// <param name="parent">The parent schema.</param>
        /// <param name="namedSchemas">The named schemas.</param>
        /// <returns>
        /// Instance of <see cref="TypeSchema" /> containing IR of the enumeration.
        /// </returns>
        /// <exception cref="System.Runtime.Serialization.SerializationException">Thrown when <paramref name="enumeration"/> contains invalid symbols.</exception>
        private TypeSchema ParseEnumType(JObject enumeration, NamedSchema parent, Dictionary <string, NamedSchema> namedSchemas)
        {
            var name     = enumeration.RequiredProperty <string>(Token.Name);
            var nspace   = this.GetNamespace(enumeration, parent, name);
            var enumName = new SchemaName(name, nspace);

            var doc        = enumeration.OptionalProperty <string>(Token.Doc);
            var aliases    = this.GetAliases(enumeration, enumName.Namespace);
            var attributes = new NamedEntityAttributes(enumName, aliases, doc);

            List <string> symbols = enumeration.OptionalArrayProperty(
                Token.Symbols,
                (symbol, index) =>
            {
                if (symbol.Type != JTokenType.String)
                {
                    throw new SerializationException(
                        string.Format(CultureInfo.InvariantCulture, "Expected an enum symbol of type string however the type of the symbol is '{0}'.", symbol.Type));
                }
                return((string)symbol);
            });

            Dictionary <string, string> customAttributes = enumeration.GetAttributesNotIn(StandardProperties.Enumeration);
            var result = new EnumSchema(attributes, typeof(AvroEnum), customAttributes);

            namedSchemas.Add(result.FullName, result);
            symbols.ForEach(result.AddSymbol);
            return(result);
        }
        /// <summary>
        /// Parses a union token.
        /// </summary>
        /// <param name="unionToken">The union token.</param>
        /// <param name="parent">The parent.</param>
        /// <param name="namedSchemas">The named schemas.</param>
        /// <returns>
        /// Schema internal representation.
        /// </returns>
        /// <exception cref="System.Runtime.Serialization.SerializationException">Thrown when union schema type is invalid.</exception>
        private TypeSchema ParseUnionType(JArray unionToken, NamedSchema parent, Dictionary <string, NamedSchema> namedSchemas)
        {
            var types   = new HashSet <string>();
            var schemas = new List <TypeSchema>();

            foreach (var typeAlternative in unionToken.Children())
            {
                var schema = this.Parse(typeAlternative, parent, namedSchemas);
                if (schema.Type == global::AvroConvert.Schema.Schema.Type.Union)
                {
                    throw new SerializationException(
                              string.Format(CultureInfo.InvariantCulture, "Union schemas cannot be nested:'{0}'.", unionToken));
                }

                if (types.Contains(schema.Type.ToString()))
                {
                    throw new SerializationException(
                              string.Format(CultureInfo.InvariantCulture, "Unions cannot contains schemas of the same type: '{0}'.", schema.Type));
                }

                types.Add(schema.Type.ToString());
                schemas.Add(schema);
            }

            return(new UnionSchema(schemas, typeof(object)));
        }
        private string GetNamespace(JObject type, NamedSchema parentSchema, string name)
        {
            var nspace = type.OptionalProperty <string>(Token.Namespace);

            if (string.IsNullOrEmpty(nspace) && !name.Contains(".") && parentSchema != null)
            {
                nspace = parentSchema.Namespace;
            }
            return(nspace);
        }
        /// <summary>
        /// Parses a JSON object representing an Avro map.
        /// </summary>
        /// <param name="map">JSON representing the map.</param>
        /// <param name="parent">The parent.</param>
        /// <param name="namedSchemas">The named schemas.</param>
        /// <returns>
        /// A corresponding schema.
        /// </returns>
        /// <exception cref="System.Runtime.Serialization.SerializationException">Thrown when 'values' property is not found in <paramref name="map" />.</exception>
        private TypeSchema ParseMapType(JObject map, NamedSchema parent, Dictionary <string, NamedSchema> namedSchemas)
        {
            var valueType = map[Token.Values];

            if (valueType == null)
            {
                throw new SerializationException(
                          string.Format(CultureInfo.InvariantCulture, "Property 'values' cannot be found inside the map '{0}'.", map));
            }

            var valueSchema = this.Parse(valueType, parent, namedSchemas);

            return(new MapSchema(new StringSchema(), valueSchema, typeof(Dictionary <string, object>)));
        }
        /// <summary>
        /// Parses a JSON object representing an Avro array.
        /// </summary>
        /// <param name="array">JSON representing the array.</param>
        /// <param name="parent">The parent.</param>
        /// <param name="namedSchemas">The named schemas.</param>
        /// <returns>
        /// A corresponding schema.
        /// </returns>
        /// <exception cref="System.Runtime.Serialization.SerializationException">Thrown when no 'items' property is found in <paramref name="array" />.</exception>
        private TypeSchema ParseArrayType(JObject array, NamedSchema parent, Dictionary <string, NamedSchema> namedSchemas)
        {
            var itemType = array[Token.Items];

            if (itemType == null)
            {
                throw new SerializationException(
                          string.Format(CultureInfo.InvariantCulture, "Property 'items' cannot be found inside the array '{0}'.", array));
            }

            var elementSchema = this.Parse(itemType, parent, namedSchemas);

            return(new ArraySchema(elementSchema, typeof(Array)));
        }
        /// <summary>
        /// Parses the JSON object.
        /// </summary>
        /// <param name="token">The object.</param>
        /// <param name="parent">The parent schema.</param>
        /// <param name="namedSchemas">The schemas.</param>
        /// <returns>
        /// Schema internal representation.
        /// </returns>
        /// <exception cref="System.Runtime.Serialization.SerializationException">Thrown when JSON schema type is invalid.</exception>
        private TypeSchema ParseJsonObject(JObject token, NamedSchema parent, Dictionary <string, NamedSchema> namedSchemas)
        {
            JToken tokenType = token[Token.Type];

            if (tokenType.Type == JTokenType.String)
            {
                var type = token.RequiredProperty <global::AvroConvert.Schema.Schema.Type>(Token.Type);
                if (PrimitiveRuntimeType.ContainsKey(type.ToString()))
                {
                    return(this.ParsePrimitiveTypeFromObject(token));
                }
                switch (type)
                {
                case global::AvroConvert.Schema.Schema.Type.Record:
                    return(this.ParseRecordType(token, parent, namedSchemas));

                case global::AvroConvert.Schema.Schema.Type.Enumeration:
                    return(this.ParseEnumType(token, parent, namedSchemas));

                case global::AvroConvert.Schema.Schema.Type.Array:
                    return(this.ParseArrayType(token, parent, namedSchemas));

                case global::AvroConvert.Schema.Schema.Type.Map:
                    return(this.ParseMapType(token, parent, namedSchemas));

                case global::AvroConvert.Schema.Schema.Type.Fixed:
                    return(this.ParseFixedType(token, parent));

                default:
                    throw new SerializationException(
                              string.Format(CultureInfo.InvariantCulture, "Invalid type specified: '{0}'.", type));
                }
            }

            if (tokenType.Type == JTokenType.Array)
            {
                return(this.ParseUnionType(tokenType as JArray, parent, namedSchemas));
            }

            throw new SerializationException(
                      string.Format(CultureInfo.InvariantCulture, "Invalid type specified: '{0}'.", tokenType));
        }
        /// <summary>
        /// Parses the record field.
        /// </summary>
        /// <param name="field">The field.</param>
        /// <param name="parent">The parent schema.</param>
        /// <param name="namedSchemas">The named schemas.</param>
        /// <param name="position">The position.</param>
        /// <returns>
        /// Schema internal representation.
        /// </returns>
        /// <exception cref="System.Runtime.Serialization.SerializationException">Thrown when <paramref name="field"/> is not valid or when sort order is not valid.</exception>
        private RecordField ParseRecordField(JObject field, NamedSchema parent, Dictionary <string, NamedSchema> namedSchemas, int position)
        {
            var name      = field.RequiredProperty <string>(Token.Name);
            var doc       = field.OptionalProperty <string>(Token.Doc);
            var order     = field.OptionalProperty <string>(Token.Order);
            var aliases   = this.GetAliases(field, parent.FullName);
            var fieldType = field[Token.Type];

            if (fieldType == null)
            {
                throw new SerializationException(
                          string.Format(CultureInfo.InvariantCulture, "Record field schema '{0}' has no type.", field));
            }

            TypeSchema type            = this.Parse(fieldType, parent, namedSchemas);
            object     defaultValue    = null;
            bool       hasDefaultValue = field[Token.Default] != null;

            if (hasDefaultValue)
            {
                var objectParser = new JsonObjectParser();
                defaultValue = objectParser.Parse(type, field[Token.Default].ToString());
            }

            var orderValue = SortOrder.Ascending;

            if (!string.IsNullOrEmpty(order))
            {
                if (!SortValue.ContainsKey(order.ToUpperInvariant()))
                {
                    throw new SerializationException(
                              string.Format(CultureInfo.InvariantCulture, "Invalid sort order of the field '{0}'.", order));
                }
                orderValue = SortValue[order.ToUpperInvariant()];
            }

            var fieldName  = new SchemaName(name);
            var attributes = new NamedEntityAttributes(fieldName, aliases, doc);

            return(new RecordField(attributes, type, orderValue, hasDefaultValue, defaultValue, null, position));
        }
        private FixedSchema ParseFixedType(JObject type, NamedSchema parent)
        {
            var name      = type.RequiredProperty <string>(Token.Name);
            var nspace    = this.GetNamespace(type, parent, name);
            var fixedName = new SchemaName(name, nspace);

            var size = type.RequiredProperty <int>(Token.Size);

            if (size <= 0)
            {
                throw new SerializationException(
                          string.Format(CultureInfo.InvariantCulture, "Only positive size of fixed values allowed: '{0}'.", size));
            }

            var aliases    = this.GetAliases(type, fixedName.Namespace);
            var attributes = new NamedEntityAttributes(fixedName, aliases, string.Empty);

            var customAttributes = type.GetAttributesNotIn(StandardProperties.Record);
            var result           = new FixedSchema(attributes, size, typeof(byte[]), customAttributes);

            return(result);
        }
Exemple #11
0
        private FixedSchema TryBuildFixedSchema(Type memberType, MemberInfo memberInfo, NamedSchema parentSchema)
        {
            var result = memberInfo.GetCustomAttributes(false).OfType <AvroFixedAttribute>().FirstOrDefault();

            if (result == null)
            {
                return(null);
            }

            if (memberType != typeof(byte[]))
            {
                throw new SerializationException(
                          string.Format(CultureInfo.InvariantCulture, "'{0}' can be set only to members of type byte[].", typeof(AvroFixedAttribute)));
            }

            var schemaNamespace = string.IsNullOrEmpty(result.Namespace) && !result.Name.Contains(".") && parentSchema != null
                                      ? parentSchema.Namespace
                                      : result.Namespace;

            return(new FixedSchema(
                       new NamedEntityAttributes(new SchemaName(result.Name, schemaNamespace), new List <string>(), string.Empty),
                       result.Size,
                       memberType));
        }
Exemple #12
0
 private bool DoNamesMatch(NamedSchema w, NamedSchema r)
 {
     return(r.FullName == w.FullName || r.Aliases.Contains(w.FullName));
 }