Example #1
0
        // constructors
        /// <summary>
        /// Initializes a new instance of the BsonBinaryWriter class.
        /// </summary>
        /// <param name="stream">A stream.</param>
        /// <param name="buffer">A BsonBuffer.</param>
        /// <param name="settings">Optional BsonBinaryWriter settings.</param>
        public BsonBinaryWriter(Stream stream, BsonBuffer buffer, BsonBinaryWriterSettings settings)
            : base(settings)
        {
            _stream = stream;
            if (buffer == null)
            {
                _buffer = new BsonBuffer();
                _disposeBuffer = true; // only call Dispose if we allocated the buffer
            }
            else
            {
                _buffer = buffer;
                _disposeBuffer = false;
            }
            _binaryWriterSettings = settings; // already frozen by base class

            _context = null;
            State = BsonWriterState.Initial;
        }
Example #2
0
 // protected methods
 /// <summary>
 /// Disposes of any resources used by the writer.
 /// </summary>
 /// <param name="disposing">True if called from Dispose.</param>
 protected override void Dispose(bool disposing)
 {
     if (disposing)
     {
         Close();
         if (_disposeBuffer)
         {
             _buffer.Dispose();
             _buffer = null;
         }
     }
 }
 // protected methods
 protected void BackpatchMessageLength(BsonBuffer buffer)
 {
     MessageLength = buffer.Position - _messageStartPosition;
     buffer.Backpatch(_messageStartPosition, MessageLength);
 }
 protected abstract void WriteBody(BsonBuffer buffer);
Example #5
0
        // public methods
        public IEnumerable <WriteConcernResult> Execute(MongoConnection connection)
        {
            var serverInstance = connection.ServerInstance;

            if (serverInstance.Supports(FeatureId.WriteCommands) && _args.WriteConcern.Enabled)
            {
                var emulator = new InsertOpcodeOperationEmulator(_args);
                return(emulator.Execute(connection));
            }

            var results        = WriteConcern.Enabled ? new List <WriteConcernResult>() : null;
            var finalException = (Exception)null;

            var requests = _args.Requests.Cast <InsertRequest>();

            if (_args.AssignId != null)
            {
                requests = requests.Select(r => { _args.AssignId(r); return(r); });
            }

            using (var enumerator = requests.GetEnumerator())
            {
                Batch <InsertRequest> nextBatch = new FirstBatch <InsertRequest>(enumerator);
                while (nextBatch != null)
                {
                    // release buffer as soon as possible
                    BatchProgress <InsertRequest>     batchProgress;
                    SendMessageWithWriteConcernResult sendBatchResult;
                    using (var buffer = new BsonBuffer(new MultiChunkBuffer(BsonChunkPool.Default), true))
                    {
                        var flags   = _continueOnError ? InsertFlags.ContinueOnError : InsertFlags.None;
                        var message = new MongoInsertMessage(
                            _args.WriterSettings,
                            _args.DatabaseName + "." + _args.CollectionName,
                            _args.CheckElementNames,
                            flags,
                            _args.MaxBatchCount,
                            _args.MaxBatchLength,
                            _args.MaxDocumentSize,
                            nextBatch);
                        message.WriteTo(buffer); // consumes as much of nextBatch as fits in one message
                        batchProgress = message.BatchProgress;

                        sendBatchResult = SendBatch(connection, buffer, message.RequestId, batchProgress.IsLast);
                    }

                    // note: getLastError is sent even when WriteConcern is not enabled if ContinueOnError is false
                    if (sendBatchResult.GetLastErrorRequestId.HasValue)
                    {
                        WriteConcernResult writeConcernResult;
                        try
                        {
                            writeConcernResult = ReadWriteConcernResult(connection, sendBatchResult);
                        }
                        catch (WriteConcernException ex)
                        {
                            writeConcernResult = ex.WriteConcernResult;
                            if (_continueOnError)
                            {
                                finalException = ex;
                            }
                            else if (WriteConcern.Enabled)
                            {
                                results.Add(writeConcernResult);
                                ex.Data["results"] = results;
                                throw;
                            }
                            else
                            {
                                return(null);
                            }
                        }

                        if (results != null)
                        {
                            results.Add(writeConcernResult);
                        }
                    }

                    nextBatch = batchProgress.NextBatch;
                }
            }

            if (WriteConcern.Enabled && finalException != null)
            {
                finalException.Data["results"] = results;
                throw finalException;
            }

            return(results);
        }
Example #6
0
 /// <summary>
 /// Creates a BsonWriter to a BsonBuffer.
 /// </summary>
 /// <param name="buffer">A BsonBuffer.</param>
 /// <param name="settings">Optional BsonBinaryWriterSettings.</param>
 /// <returns>A BsonWriter.</returns>
 public static BsonWriter Create(BsonBuffer buffer, BsonBinaryWriterSettings settings)
 {
     return new BsonBinaryWriter(null, buffer, settings);
 }
        public IEnumerable <WriteConcernResult> Execute(MongoConnection connection)
        {
            WriteConcernException     finalException = null;
            List <WriteConcernResult> results        = (WriteConcern.Enabled) ? new List <WriteConcernResult>() : null;

            using (var bsonBuffer = new BsonBuffer(new MultiChunkBuffer(BsonChunkPool.Default), true))
            {
                var readerSettings = GetNodeAdjustedReaderSettings(connection.ServerInstance);
                var writerSettings = GetNodeAdjustedWriterSettings(connection.ServerInstance);
                var message        = new MongoInsertMessage(writerSettings, CollectionFullName, _checkElementNames, _flags);
                message.WriteToBuffer(bsonBuffer); // must be called before AddDocument

                var writeConcernEnabled = WriteConcern.Enabled;
                var continueOnError     = (_flags & InsertFlags.ContinueOnError) != 0;

                foreach (var document in _documents)
                {
                    if (document == null)
                    {
                        throw new ArgumentException("Batch contains one or more null documents.");
                    }

                    if (_assignIdOnInsert)
                    {
                        var serializer = BsonSerializer.LookupSerializer(document.GetType());
                        var idProvider = serializer as IBsonIdProvider;
                        if (idProvider != null)
                        {
                            object       id;
                            Type         idNominalType;
                            IIdGenerator idGenerator;
                            if (idProvider.GetDocumentId(document, out id, out idNominalType, out idGenerator))
                            {
                                if (idGenerator != null && idGenerator.IsEmpty(id))
                                {
                                    id = idGenerator.GenerateId(_idGeneratorContainer, document);
                                    idProvider.SetDocumentId(document, id);
                                }
                            }
                        }
                    }
                    message.AddDocument(bsonBuffer, _documentType, document);

                    if (message.MessageLength > connection.ServerInstance.MaxMessageLength)
                    {
                        byte[] lastDocument = message.RemoveLastDocument(bsonBuffer);

                        if (writeConcernEnabled && !continueOnError)
                        {
                            try
                            {
                                var result = SendMessageWithWriteConcern(connection, bsonBuffer, message.RequestId, readerSettings, writerSettings, WriteConcern);
                                results.Add(result);
                            }
                            catch (WriteConcernException ex)
                            {
                                results.Add((WriteConcernResult)ex.CommandResult);
                                ex.Data["results"] = results;
                                throw ex;
                            }
                        }
                        else if (writeConcernEnabled && continueOnError)
                        {
                            try
                            {
                                var result = SendMessageWithWriteConcern(connection, bsonBuffer, message.RequestId, readerSettings, writerSettings, WriteConcern);
                                results.Add(result);
                            }
                            catch (WriteConcernException ex)
                            {
                                finalException = ex;
                                results.Add((WriteConcernResult)ex.CommandResult);
                            }
                        }
                        else if (!writeConcernEnabled && !continueOnError)
                        {
                            try
                            {
                                SendMessageWithWriteConcern(connection, bsonBuffer, message.RequestId, readerSettings, writerSettings, WriteConcern.Acknowledged);
                            }
                            catch (WriteConcernException)
                            {
                                return(null);
                            }
                        }
                        else if (!writeConcernEnabled && continueOnError)
                        {
                            SendMessageWithWriteConcern(connection, bsonBuffer, message.RequestId, readerSettings, writerSettings, WriteConcern.Unacknowledged);
                        }

                        message.ResetBatch(bsonBuffer, lastDocument);
                    }
                }

                if (writeConcernEnabled)
                {
                    try
                    {
                        var result = SendMessageWithWriteConcern(connection, bsonBuffer, message.RequestId, readerSettings, writerSettings, WriteConcern);
                        results.Add(result);
                    }
                    catch (WriteConcernException ex)
                    {
                        finalException = ex;
                        results.Add((WriteConcernResult)ex.CommandResult);
                    }

                    if (finalException != null)
                    {
                        finalException.Data["results"] = results;
                        throw finalException;
                    }

                    return(results);
                }
                else
                {
                    SendMessageWithWriteConcern(connection, bsonBuffer, message.RequestId, readerSettings, writerSettings, WriteConcern.Unacknowledged);
                    return(null);
                }
            }
        }
Example #8
0
        // private methods
        private SendMessageWithWriteConcernResult SendBatch(MongoConnection connection, BsonBuffer buffer, int requestId, bool isLast)
        {
            var writeConcern = WriteConcern;

            if (!writeConcern.Enabled && !_continueOnError && !isLast)
            {
                writeConcern = WriteConcern.Acknowledged;
            }
            return(SendMessageWithWriteConcern(connection, buffer, requestId, ReaderSettings, WriterSettings, writeConcern));
        }
Example #9
0
 internal void ReadFrom(BsonBuffer buffer)
 {
     ReadHeaderFrom(buffer);
     ReadBodyFrom(buffer);
 }
 internal override void WriteHeaderTo(BsonBuffer buffer)
 {
     base.WriteHeaderTo(buffer);
     buffer.WriteInt32(0); // reserved
 }
Example #11
0
        static void Main(string[] args)
        {
            FileInfo assemblyFileInfo = new FileInfo(args[0]);
            string   savePath         = args[1];

            DirectoryInfo fireMLDirInfo  = assemblyFileInfo.Directory;
            DirectoryInfo contentDirInfo = fireMLDirInfo.Parent;

            List <string> plotFileList  = new List <string>();
            List <string> assetFileList = new List <string>();

            foreach (FileInfo fileInfo in fireMLDirInfo.GetFiles("*.*", SearchOption.AllDirectories))
            {
                string ext = fileInfo.Extension;
                if (ext == ".fmlplot")
                {
                    plotFileList.Add(fileInfo.FullName);
                }
                else if (ext == ".fmlasset")
                {
                    assetFileList.Add(fileInfo.FullName);
                }
            }

            string xsdDirPath = fireMLDirInfo.FullName + "\\" + "XSD";

            //FireEngine.XNAContent.ContentManager contentManager = new FireEngine.XNAContent.ContentManager(contentDirInfo.FullName);
            CompilerKernel kernel = new CompilerKernel(plotFileList.ToArray(), assetFileList.ToArray(), xsdDirPath, null /*contentManager*/);
            FireMLRoot     result = kernel.CompileFireML();

            Error[] errors = kernel.CheckPoint();

            foreach (Error e in errors)
            {
                Console.WriteLine("{0}\n{1},{2}\n{3}", e.Location.FileName, e.Location.Line, e.Location.Column, e.Message);
                Console.WriteLine();
            }

            if (errors.Length > 0)
            {
                Environment.Exit(-1);
                return;
            }

            Stream     bsonStream = new FileStream(savePath, FileMode.Create);
            BsonBuffer bsonBuffer = new BsonBuffer();
            BsonBinaryWriterSettings bsonSettings = new BsonBinaryWriterSettings();
            BsonBinaryWriter         bsonWriter   = new BsonBinaryWriter(bsonStream, bsonBuffer, bsonSettings);

            BsonSerializer.Serialize <FireMLRoot>(bsonWriter, result);
            bsonWriter.Close();

            JsonWriterSettings jsonSettings = new JsonWriterSettings();

            jsonSettings.NewLineChars = "\r\n";
            jsonSettings.OutputMode   = JsonOutputMode.JavaScript;
            jsonSettings.Indent       = true;
            jsonSettings.IndentChars  = "  ";
            StreamWriter streamWriter = new StreamWriter(new FileStream(savePath + ".json", FileMode.Create));
            JsonWriter   jsonWriter   = new JsonWriter(streamWriter, jsonSettings);

            BsonSerializer.Serialize <FireMLRoot>(jsonWriter, result);
            jsonWriter.Close();
        }
Example #12
0
 // internal methods
 internal override void WriteBodyTo(BsonBuffer buffer)
 {
     buffer.WriteInt64(_cursorId);
 }
        /// <summary>
        /// Writes a raw BSON array.
        /// </summary>
        /// <param name="slice">The byte buffer containing the raw BSON array.</param>
        public virtual void WriteRawBsonArray(IByteBuffer slice)
        {
            // overridden in BsonBinaryWriter

            using (var bsonBuffer = new BsonBuffer())
            {
                BsonArray array;

                // wrap the array in a fake document so we can deserialize it
                var arrayLength = slice.Length;
                var documentLength = arrayLength + 8;
                bsonBuffer.WriteInt32(documentLength);
                bsonBuffer.WriteByte((byte)BsonType.Array);
                bsonBuffer.WriteByte((byte)'x');
                bsonBuffer.WriteByte((byte)0);
                bsonBuffer.ByteBuffer.WriteBytes(slice);
                bsonBuffer.WriteByte((byte)0);

                bsonBuffer.Position = 0;
                using (var bsonReader = new BsonBinaryReader(bsonBuffer, true, BsonBinaryReaderSettings.Defaults))
                {
                    bsonReader.ReadStartDocument();
                    bsonReader.ReadName("x");
                    array = (BsonArray)BsonArraySerializer.Instance.Deserialize(bsonReader, typeof(BsonArray), null);
                    bsonReader.ReadEndDocument();
                }

                BsonArraySerializer.Instance.Serialize(this, typeof(BsonArray), array, null);
            }
        }