mcs/class/RabbitMQ.Client/src/client/impl/Command.cs

   1 // This source code is dual-licensed under the Apache License, version
   2 // 2.0, and the Mozilla Public License, version 1.1.
   3 //
   4 // The APL v2.0:
   5 //
   6 //---------------------------------------------------------------------------
   7 //   Copyright (C) 2007-2009 LShift Ltd., Cohesive Financial
   8 //   Technologies LLC., and Rabbit Technologies Ltd.
   9 //
  10 //   Licensed under the Apache License, Version 2.0 (the "License");
  11 //   you may not use this file except in compliance with the License.
  12 //   You may obtain a copy of the License at
  13 //
  14 //       http://www.apache.org/licenses/LICENSE-2.0
  15 //
  16 //   Unless required by applicable law or agreed to in writing, software
  17 //   distributed under the License is distributed on an "AS IS" BASIS,
  18 //   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  19 //   See the License for the specific language governing permissions and
  20 //   limitations under the License.
  21 //---------------------------------------------------------------------------
  22 //
  23 // The MPL v1.1:
  24 //
  25 //---------------------------------------------------------------------------
  26 //   The contents of this file are subject to the Mozilla Public License
  27 //   Version 1.1 (the "License"); you may not use this file except in
  28 //   compliance with the License. You may obtain a copy of the License at
  29 //   http://www.rabbitmq.com/mpl.html
  30 //
  31 //   Software distributed under the License is distributed on an "AS IS"
  32 //   basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See the
  33 //   License for the specific language governing rights and limitations
  34 //   under the License.
  35 //
  36 //   The Original Code is The RabbitMQ .NET Client.
  37 //
  38 //   The Initial Developers of the Original Code are LShift Ltd,
  39 //   Cohesive Financial Technologies LLC, and Rabbit Technologies Ltd.
  40 //
  41 //   Portions created before 22-Nov-2008 00:00:00 GMT by LShift Ltd,
  42 //   Cohesive Financial Technologies LLC, or Rabbit Technologies Ltd
  43 //   are Copyright (C) 2007-2008 LShift Ltd, Cohesive Financial
  44 //   Technologies LLC, and Rabbit Technologies Ltd.
  45 //
  46 //   Portions created by LShift Ltd are Copyright (C) 2007-2009 LShift
  47 //   Ltd. Portions created by Cohesive Financial Technologies LLC are
  48 //   Copyright (C) 2007-2009 Cohesive Financial Technologies
  49 //   LLC. Portions created by Rabbit Technologies Ltd are Copyright
  50 //   (C) 2007-2009 Rabbit Technologies Ltd.
  51 //
  52 //   All Rights Reserved.
  53 //
  54 //   Contributor(s): ______________________________________.
  55 //
  56 //---------------------------------------------------------------------------
  57 using System;
  58 using System.IO;
  59 using System.Collections;
  60
  61 using RabbitMQ.Util;
  62
  63 // We use spec version 0-9 for common constants such as frame types
  64 // and the frame end byte, since they don't vary *within the versions
  65 // we support*. Obviously we may need to revisit this if that ever
  66 // changes.
  67 using CommonFraming = RabbitMQ.Client.Framing.v0_9;
  68 using System.Diagnostics;
  69 using System.Net;
  70
  71 namespace RabbitMQ.Client.Impl {
  72     public class Command {
  73         private static readonly byte[] m_emptyByteArray = new byte[0];
  74
  75         // EmptyContentBodyFrameSize, 8 = 1 + 2 + 4 + 1
  76         // - 1 byte of frame type
  77         // - 2 bytes of channel number
  78         // - 4 bytes of frame payload length
  79         // - 1 byte of payload trailer FrameEnd byte
  80         public const int EmptyContentBodyFrameSize = 8;
  81
  82         static Command() {
  83             CheckEmptyContentBodyFrameSize();
  84         }
  85
  86         public static void CheckEmptyContentBodyFrameSize() {
  87             Frame f = new Frame(CommonFraming.Constants.FrameBody, 0, m_emptyByteArray);
  88             MemoryStream stream = new MemoryStream();
  89             NetworkBinaryWriter writer = new NetworkBinaryWriter(stream);
  90             f.WriteTo(writer);
  91             long actualLength = stream.Length;
  92
  93             if (EmptyContentBodyFrameSize != actualLength) {
  94                 string message =
  95                     string.Format("EmptyContentBodyFrameSize is incorrect - defined as {0} where the computed value is in fact {1}.",
  96                                   EmptyContentBodyFrameSize,
  97                                   actualLength);
  98                 throw new ProtocolViolationException(message);
  99             }
 100         }
 101
 102         ///////////////////////////////////////////////////////////////////////////
 103
 104         public MethodBase m_method;
 105         public ContentHeaderBase m_header;
 106         public byte[] m_body0;
 107         public ArrayList m_bodyN;
 108
 109         public MethodBase Method { get { return m_method; } }
 110         public ContentHeaderBase Header { get { return m_header; } }
 111         public byte[] Body { get { return ConsolidateBody(); } }
 112
 113         public Command(): this(null, null, null) {}
 114
 115         public Command(MethodBase method): this(method, null, null) {}
 116
 117         public Command(MethodBase method, ContentHeaderBase header, byte[] body) {
 118             m_method = method;
 119             m_header = header;
 120             m_body0 = body;
 121             m_bodyN = null;
 122         }
 123
 124         public byte[] ConsolidateBody() {
 125             if (m_bodyN == null) {
 126                 return (m_body0 == null) ? m_emptyByteArray : m_body0;
 127             } else {
 128                 int totalSize = m_body0.Length;
 129                 foreach (byte[] fragment in m_bodyN) {
 130                     totalSize += fragment.Length;
 131                 }
 132                 byte[] result = new byte[totalSize];
 133                 Array.Copy(m_body0, 0, result, 0, m_body0.Length);
 134                 int offset = m_body0.Length;
 135                 foreach (byte[] fragment in m_bodyN) {
 136                     Array.Copy(fragment, 0, result, offset, fragment.Length);
 137                     offset += fragment.Length;
 138                 }
 139                 m_body0 = result;
 140                 m_bodyN = null;
 141                 return m_body0;
 142             }
 143         }
 144
 145         public void AppendBodyFragment(byte[] fragment) {
 146             if (m_body0 == null) {
 147                 m_body0 = fragment;
 148             } else {
 149                 if (m_bodyN == null) {
 150                     m_bodyN = new ArrayList();
 151                 }
 152                 m_bodyN.Add(fragment);
 153             }
 154         }
 155
 156         public void Transmit(int channelNumber, ConnectionBase connection) {
 157             Frame frame = new Frame(CommonFraming.Constants.FrameMethod, channelNumber);
 158             NetworkBinaryWriter writer = frame.GetWriter();
 159             writer.Write((ushort) m_method.ProtocolClassId);
 160             writer.Write((ushort) m_method.ProtocolMethodId);
 161             MethodArgumentWriter argWriter = new MethodArgumentWriter(writer);
 162             m_method.WriteArgumentsTo(argWriter);
 163             argWriter.Flush();
 164             connection.WriteFrame(frame);
 165
 166             if (m_method.HasContent) {
 167                 byte[] body = Body;
 168
 169                 frame = new Frame(CommonFraming.Constants.FrameHeader, channelNumber);
 170                 writer = frame.GetWriter();
 171                 writer.Write((ushort) m_header.ProtocolClassId);
 172                 m_header.WriteTo(writer, (ulong) body.Length);
 173                 connection.WriteFrame(frame);
 174
 175                 int frameMax = (int) Math.Min(int.MaxValue, connection.FrameMax);
 176                 int bodyPayloadMax = (frameMax == 0)
 177                     ? body.Length
 178                     : frameMax - EmptyContentBodyFrameSize;
 179                 for (int offset = 0; offset < body.Length; offset += bodyPayloadMax) {
 180                     int remaining = body.Length - offset;
 181
 182                     frame = new Frame(CommonFraming.Constants.FrameBody, channelNumber);
 183                     writer = frame.GetWriter();
 184                     writer.Write(body, offset,
 185                                  (remaining < bodyPayloadMax) ? remaining : bodyPayloadMax);
 186                     connection.WriteFrame(frame);
 187                 }
 188             }
 189         }
 190     }
 191 }