public void VisitReceiveLocation <TNamingConvention>(IReceiveLocation <TNamingConvention> receiveLocation) where TNamingConvention : class
 {
     if (receiveLocation == null)
     {
         throw new ArgumentNullException(nameof(receiveLocation));
     }
     ((ISupportValidation)receiveLocation).Validate();
 }
Example #2
0
 public void VisitReceiveLocation <TNamingConvention>(IReceiveLocation <TNamingConvention> receiveLocation) where TNamingConvention : class
 {
     if (receiveLocation == null)
     {
         throw new ArgumentNullException(nameof(receiveLocation));
     }
     ((ISupportEnvironmentOverride)receiveLocation).ApplyEnvironmentOverrides(Environment);
 }
 internal static string ComputeReceiveLocationName <TNamingConvention>(IReceiveLocation <TNamingConvention> receiveLocation)
     where TNamingConvention : class
 {
     return(ComputeName(
                receiveLocation,
                "Receive Location",
                convention => convention.ComputeReceiveLocationName(receiveLocation)));
 }
        protected string ComputeReceiveLocationName(IReceiveLocation <TNamingConvention> receiveLocation)
        {
            if (receiveLocation == null)
            {
                throw new ArgumentNullException(nameof(receiveLocation));
            }
            if (receiveLocation.ReceivePort == null)
            {
                throw new NamingConventionException($"'{receiveLocation.GetType().Name}' ReceiveLocation is not bound to any receive port.");
            }
            if (Equals(Party, default(TParty)))
            {
                Party = receiveLocation.ReceivePort.Name.Party;
            }
            if (Equals(Party, default(TParty)))
            {
                throw new NamingConventionException($"'{receiveLocation.GetType().Name}' ReceiveLocation's Party is required.");
            }
            if (!Equals(Party, receiveLocation.ReceivePort.Name.Party))
            {
                throw new NamingConventionException(
                          $"'{receiveLocation.GetType().Name}' ReceiveLocation's Party, '{Party}', does not match its ReceivePort's one, '{receiveLocation.ReceivePort.Name.Party}'.");
            }
            if (Equals(Subject, default(TSubject)))
            {
                throw new NamingConventionException($"'{receiveLocation.GetType().Name}' ReceiveLocation's Subject is required.");
            }
            if (MessageFormat == null)
            {
                throw new NamingConventionException("A non null MessageFormat is required.");
            }

            var aggregate            = ComputeAggregateName(receiveLocation.GetType());
            var receivePortAggregate = ComputeAggregateName(receiveLocation.ReceivePort.GetType());

            if (aggregate.IsNullOrEmpty() && !receivePortAggregate.IsNullOrEmpty())
            {
                aggregate = receivePortAggregate;
            }
            if (!receivePortAggregate.IsNullOrEmpty() && receivePortAggregate != aggregate)
            {
                throw new NamingConventionException(
                          $"'{receiveLocation.GetType().Name}' ReceiveLocation's Aggregate, '{aggregate}', does not match its ReceivePort's one, '{receivePortAggregate}'.");
            }

            return(string.Format(
                       CultureInfo.InvariantCulture,
                       "{0}{1}.RL{2}.{3}.{4}.{5}{6}",
                       receiveLocation.ReceivePort.ApplicationBinding.ResolveName(),
                       aggregate.IsNullOrEmpty() ? string.Empty : $".{aggregate}",
                       receiveLocation.ReceivePort.IsTwoWay ? "2" : "1",
                       Party,
                       Subject,
                       ComputeAdapterName(receiveLocation.Transport.Adapter),
                       MessageFormat.IsNullOrEmpty() ? string.Empty : $".{MessageFormat}"));
        }
Example #5
0
        public void VisitReceiveLocation <TNamingConvention>(IReceiveLocation <TNamingConvention> receiveLocation)
            where TNamingConvention : class
        {
            var fileAdapter = receiveLocation.Transport.Adapter as FileAdapter.Inbound;

            if (fileAdapter != null)
            {
                VisitDirectory(fileAdapter.ReceiveFolder);
            }
        }
 public void VisitReceiveLocation <TNamingConvention>(IReceiveLocation <TNamingConvention> receiveLocation)
     where TNamingConvention : class
 {
     // skip ReceiveLocation not belonging to this application
     if (!ReferenceEquals(receiveLocation.ReceivePort.ApplicationBinding, _applicationBinding))
     {
         return;
     }
     _decoratedVisitor.VisitReceiveLocation(receiveLocation);
 }
Example #7
0
        protected internal override void VisitReceiveLocation <TNamingConvention>(IReceiveLocation <TNamingConvention> receiveLocation)
            where TNamingConvention : class
        {
            var visitedReceiveLocation = CreateReceiveLocation(receiveLocation);

            if (_lastVisitedReceivePort.ReceiveLocations.Cast <BtsReceiveLocation>().Any(rl => rl.Name == visitedReceiveLocation.Name))
            {
                throw new BindingException($"Duplicate receive location name: '{visitedReceiveLocation.Name}'.");
            }
            _lastVisitedReceivePort.ReceiveLocations.Add(visitedReceiveLocation);
        }
 void IApplicationBindingVisitor.VisitReceiveLocation <TNamingConvention>(IReceiveLocation <TNamingConvention> receiveLocation)
     where TNamingConvention : class
 {
     if (receiveLocation == null)
     {
         throw new ArgumentNullException(nameof(receiveLocation));
     }
     // visit only ReceiveLocation belonging to this application
     if (ReferenceEquals(receiveLocation.ReceivePort.ApplicationBinding, _mainApplicationBinding))
     {
         VisitReceiveLocation(receiveLocation);
     }
 }
        public void VisitReceiveLocation <TNamingConvention>(IReceiveLocation <TNamingConvention> receiveLocation)
            where TNamingConvention : class
        {
            var visitedReceiveLocation = CreateReceiveLocation(receiveLocation);

            if (_lastVisitedReceivePort.ReceiveLocations.Cast <BtsReceiveLocation>().Any(rl => rl.Name == visitedReceiveLocation.Name))
            {
                throw new InvalidOperationException(
                          string.Format(
                              "Duplicate receive location name: '{0}'.",
                              visitedReceiveLocation.Name));
            }
            _lastVisitedReceivePort.ReceiveLocations.Add(visitedReceiveLocation);
        }
Example #10
0
        public void VisitReceiveLocation <TNamingConvention>(IReceiveLocation <TNamingConvention> receiveLocation)
            where TNamingConvention : class
        {
            var name = ((ISupportNamingConvention)receiveLocation).Name;
            var rl   = _receivePort.ReceiveLocations[name];

            if (_logger.IsDebugEnabled)
            {
                _logger.DebugFormat(
                    receiveLocation.Enabled ? "Enabling receive location '{0}'" : "Disabling receive location '{0}'",
                    name);
            }
            rl.Enabled = receiveLocation.Enabled;
        }
 string INamingConvention <NamingConvention <TParty, TSubject> > .ComputeReceiveLocationName(IReceiveLocation <NamingConvention <TParty, TSubject> > receiveLocation)
 {
     return(base.ComputeReceiveLocationName(receiveLocation));
 }
Example #12
0
        /// <summary>
        /// Creates receive port with one request-response HTTP receive location
        /// </summary>
        /// <param name="virtualDirectory">Virtual directory name</param>
        /// <param name="portName">Receive port name</param>
        /// <param name="locationName">Receive location name</param>
        /// <returns>True if successful, otherwise false</returns>
        public static bool CreateHttpRequestResponsePort(string virtualDirectory, string portName, string locationName, ref string retMsg)
        {
            IBtsCatalogExplorer explorer = null;

            try
            {
                string mgmtDBName   = "BizTalkMgmtDb";
                string mgmtDBServer = "localhost";

                ManagementClass groupSettings = new ManagementClass("root\\MicrosoftBizTalkServer:MSBTS_GroupSetting");
                foreach (ManagementObject obj in groupSettings.GetInstances())
                {
                    mgmtDBName   = (string)obj.Properties["MgmtDbName"].Value;
                    mgmtDBServer = (string)obj.Properties["MgmtDbServerName"].Value;
                }

                // Get BizTalk Explorer object
                explorer = new BtsCatalogExplorer();
                explorer.ConnectionString = "SERVER=" + mgmtDBServer + ";DATABASE=" + mgmtDBName + ";Integrated Security=SSPI";

                // Delete this port if it already exists
                foreach (IReceivePort port in explorer.GetCollection(CollectionType.ReceivePort))
                {
                    if (port.Name.ToLower() == portName.ToLower())
                    {
                        explorer.RemoveReceivePort(port);
                        break;
                    }
                }
                explorer.SaveChanges();

                // Add new port
                IReceivePort receivePort = explorer.AddNewReceivePort(true);
                receivePort.Name = portName;

                // Add new location
                IReceiveLocation rxLocation = receivePort.AddNewReceiveLocation();
                rxLocation.Name = locationName;

                // Set the receive location
                rxLocation.Address = "/" + virtualDirectory + "/BTSHttpReceive.dll";

                // Set the transport type
                foreach (IProtocolType protocol in explorer.GetCollection(CollectionType.ProtocolType))
                {
                    if (protocol.Name == "HTTP")
                    {
                        rxLocation.TransportType = protocol;
                    }
                }

                // Set the transport data
                rxLocation.TransportTypeData =
                    "<CustomProps>" +
                    "<Address vt=\"8\">" + rxLocation.Address + "</Address>" +
                    "<LoopBack vt=\"11\">0</LoopBack>" +
                    "<IsSynchronous vt=\"11\">1</IsSynchronous>" +
                    "<ReturnCorrelationHandle vt=\"11\">0</ReturnCorrelationHandle>" +
                    "<ResponseContentType vt=\"8\">text/html</ResponseContentType>" +
                    "<URI vt=\"8\">" + rxLocation.Address + "</URI>" +
                    "<UseSSO vt=\"11\">1</UseSSO>" +
                    "</CustomProps>";

                // Set the receive pipeline
                foreach (IPipeline pipe in explorer.GetCollection(CollectionType.Pipeline))
                {
                    if ((pipe.Type == PipelineType.Receive) && (pipe.FullName == "Microsoft.BizTalk.DefaultPipelines.PassThruReceive"))
                    {
                        rxLocation.ReceivePipeline = pipe;
                        break;
                    }
                }

                // Set the receive handler
                foreach (IReceiveHandler handler in explorer.GetCollection(CollectionType.ReceiveHandler))
                {
                    if (handler.TransportType == rxLocation.TransportType)
                    {
                        rxLocation.ReceiveHandler = handler;
                        break;
                    }
                }

                foreach (IPipeline pipe in explorer.GetCollection(CollectionType.Pipeline))
                {
                    if ((pipe.Type == PipelineType.Send) && (pipe.FullName == "Microsoft.BizTalk.DefaultPipelines.PassThruTransmit"))
                    {
                        receivePort.SendPipeline = pipe;
                        break;
                    }
                }

                // Enable this receive location
                rxLocation.Enable = true;

                // Save changes
                explorer.SaveChanges();
            }
            catch (Exception e)
            {
                retMsg = e.Message.ToString();
                if (explorer != null)
                {
                    explorer.DiscardChanges();
                }
                return(false);
            }

            return(true);
        }
Example #13
0
 string INamingConvention <NamingConventionSpy> .ComputeReceiveLocationName(IReceiveLocation <NamingConventionSpy> receiveLocation)
 {
     throw new NotSupportedException();
 }
        protected string ComputeReceiveLocationName(IReceiveLocation <TNamingConvention> receiveLocation)
        {
            if (receiveLocation.ReceivePort == null)
            {
                throw new NamingConventionException(
                          string.Format(
                              "'{0}' ReceiveLocation is not bound to any receive port.",
                              receiveLocation.GetType().Name));
            }
            if (Equals(Party, default(TParty)))
            {
                Party = receiveLocation.ReceivePort.Name.Party;
            }
            if (Equals(Party, default(TParty)))
            {
                throw new NamingConventionException(
                          string.Format(
                              "'{0}' ReceiveLocation's Party is required.",
                              receiveLocation.GetType().Name));
            }
            if (!Equals(Party, receiveLocation.ReceivePort.Name.Party))
            {
                throw new NamingConventionException(
                          string.Format(
                              "'{0}' ReceiveLocation's Party, '{1}', does not match its ReceivePort's one, '{2}'.",
                              receiveLocation.GetType().Name,
                              Party,
                              receiveLocation.ReceivePort.Name.Party));
            }
            if (Equals(MessageName, default(TMessageName)))
            {
                throw new NamingConventionException(
                          string.Format(
                              "'{0}' ReceiveLocation's MessageName is required.",
                              receiveLocation.GetType().Name));
            }
            if (MessageFormat == null)
            {
                throw new NamingConventionException("A non null MessageFormat is required.");
            }

            var area            = ComputeArea(receiveLocation.GetType());
            var receivePortArea = ComputeArea(receiveLocation.ReceivePort.GetType());

            if (area.IsNullOrEmpty() && !receivePortArea.IsNullOrEmpty())
            {
                area = receivePortArea;
            }
            if (!receivePortArea.IsNullOrEmpty() && receivePortArea != area)
            {
                throw new NamingConventionException(
                          string.Format(
                              "'{0}' ReceiveLocation's Area, '{1}', does not match its ReceivePort's one, '{2}'.",
                              receiveLocation.GetType().Name,
                              area,
                              receivePortArea));
            }

            return(string.Format(
                       "{0}{1}.RL{2}.{3}.{4}.{5}{6}",
                       ((ISupportNamingConvention)receiveLocation.ReceivePort.ApplicationBinding).Name,
                       area.IsNullOrEmpty() ? string.Empty : string.Format(".{0}", area),
                       receiveLocation.ReceivePort.IsTwoWay ? "2" : "1",
                       Party,
                       MessageName,
                       ComputeAdapterName(receiveLocation.Transport.Adapter),
                       MessageFormat.IsNullOrEmpty() ? string.Empty : string.Format(".{0}", MessageFormat)));
        }
 IReceiveLocationCollection <TNamingConvention> IReceiveLocationCollection <TNamingConvention> .Add(IReceiveLocation <TNamingConvention> receiveLocation)
 {
     return(((IReceiveLocationCollection <TNamingConvention>) this).Add(new[] { receiveLocation }));
 }
 protected internal abstract void VisitReceiveLocation <TNamingConvention>(IReceiveLocation <TNamingConvention> receiveLocation) where TNamingConvention : class;
Example #17
0
 public ReceiveLocationTransport(IReceiveLocation <TNamingConvention> receiveLocation) : this()
 {
     ReceiveLocation = receiveLocation ?? throw new ArgumentNullException(nameof(receiveLocation));
 }
 public void VisitReceiveLocation <TNamingConvention>(IReceiveLocation <TNamingConvention> receiveLocation) where TNamingConvention : class
 {
     ((ISupportEnvironmentOverride)receiveLocation).ApplyEnvironmentOverrides(Environment);
     ((ISupportValidation)receiveLocation).Validate();
 }
 string INamingConvention <NamingConventionDouble> .ComputeReceiveLocationName(IReceiveLocation <NamingConventionDouble> receiveLocation)
 {
     throw new NotImplementedException();
 }
 public string ComputeReceiveLocationNameSpy(IReceiveLocation <NamingConventionDouble> receiveLocation)
 {
     return(ComputeReceiveLocationName(receiveLocation));
 }
        protected internal virtual BtsReceiveLocation CreateReceiveLocation <TNamingConvention>(IReceiveLocation <TNamingConvention> receiveLocation)
            where TNamingConvention : class
        {
            ((ISupportValidation)receiveLocation).Validate();

            var location = new BtsReceiveLocation {
                Name           = ((ISupportNamingConvention)receiveLocation).Name,
                Address        = receiveLocation.Transport.Adapter.Address,
                Description    = receiveLocation.Description,
                Enable         = false,         // receiveLocation.Enabled is the responsibility of BizTalkServiceConfiguratorVisitor
                EndDate        = receiveLocation.Transport.Schedule.StopDate,
                EndDateEnabled = receiveLocation.Transport.Schedule.StopDateEnabled,
                // TODO EncryptionCert =
                FromTime = receiveLocation.Transport.Schedule.ServiceWindow.StartTime,
                // TODO Primary =
                PublicAddress  = receiveLocation.Transport.Adapter.PublicAddress,
                ReceiveHandler = new ReceiveHandlerRef {
                    // TODO HostTrusted = ,
                    Name          = receiveLocation.Transport.Host,
                    TransportType = receiveLocation.Transport.Adapter.ProtocolType
                },
                ReceivePipeline      = CreateReceivePipelineRef(receiveLocation.ReceivePipeline),
                ReceivePipelineData  = ((IPipelineSerializerFactory)receiveLocation.ReceivePipeline).GetPipelineBindingSerializer().Serialize(),
                ServiceWindowEnabled = receiveLocation.Transport.Schedule.ServiceWindow.Enabled,
                StartDate            = receiveLocation.Transport.Schedule.StartDate,
                StartDateEnabled     = receiveLocation.Transport.Schedule.StartDateEnabled,
                ToTime            = receiveLocation.Transport.Schedule.ServiceWindow.StopTime,
                TransportType     = receiveLocation.Transport.Adapter.ProtocolType,
                TransportTypeData = ((IAdapterBindingSerializerFactory)receiveLocation.Transport.Adapter).GetAdapterBindingSerializer().Serialize()
            };

            if (receiveLocation.SendPipeline != null)
            {
                location.SendPipeline = CreateSendPipelineRef(receiveLocation.SendPipeline);

                location.SendPipelineData = ((IPipelineSerializerFactory)receiveLocation.SendPipeline).GetPipelineBindingSerializer().Serialize();
            }
            return(location);
        }
Example #22
0
 string INamingConvention <NamingConvention> .ComputeReceiveLocationName(IReceiveLocation <NamingConvention> receiveLocation)
 {
     return(base.ComputeReceiveLocationName(receiveLocation));
 }