Exemple #1
0
        public void ResolveNoEndpoint()
        {
            ServiceEndpointCollection endpoints = MetadataResolver.Resolve(
                typeof(NonExistantContract),
                new EndpointAddress(url));

            Assert.IsNotNull(endpoints);
            Assert.AreEqual(0, endpoints.Count);
        }
Exemple #2
0
        public void Resolve2()
        {
            ServiceEndpointCollection endpoints = MetadataResolver.Resolve(
                typeof(IEchoService),
                new Uri(url),
                MetadataExchangeClientMode.MetadataExchange);

            CheckIEchoServiceEndpoint(endpoints);
        }
        public ServiceMetadataInformation ImportMetadata(Collection<MetadataSection> metadataCollection, MetadataImporterSerializerFormatMode formatMode)
        {
            CodeCompileUnit codeCompileUnit = new CodeCompileUnit();
            CodeDomProvider codeDomProvider = m_CodeDomProviderFactory.CreateProvider();

            WsdlImporter importer = new WsdlImporter(new MetadataSet(metadataCollection));
            switch (formatMode)
            {
                case MetadataImporterSerializerFormatMode.DataContractSerializer:
                    AddStateForDataContractSerializerImport(importer, formatMode, codeCompileUnit, codeDomProvider);
                    break;
                case MetadataImporterSerializerFormatMode.XmlSerializer:
                    AddStateForXmlSerializerImport(importer, codeCompileUnit, codeDomProvider);
                    break;
                case MetadataImporterSerializerFormatMode.Auto:
                    AddStateForDataContractSerializerImport(importer, formatMode, codeCompileUnit, codeDomProvider);
                    AddStateForXmlSerializerImport(importer, codeCompileUnit, codeDomProvider);
                    break;
            }

            if (!importer.State.ContainsKey(typeof(WrappedOptions)))
            {
                importer.State.Add(typeof(WrappedOptions), new WrappedOptions
                {
                    WrappedFlag = false
                });
            }

            Collection<Binding> bindings = importer.ImportAllBindings();
            Collection<ContractDescription> contracts = importer.ImportAllContracts();
            ServiceEndpointCollection endpoints = importer.ImportAllEndpoints();
            Collection<MetadataConversionError> importErrors = importer.Errors;

            bool success = true;
            if (importErrors != null)
            {
                foreach (MetadataConversionError error in importErrors)
                {
                    if (!error.IsWarning)
                    {
                        success = false;
                        break;
                    }
                }
            }
            if (!success)
            {
                //TODO: Throw exception
            }
           return new ServiceMetadataInformation(codeCompileUnit, codeDomProvider)
               {
                   Bindings = bindings,
                   Contracts = contracts,
                   Endpoints = endpoints
               };
        }
Exemple #4
0
        private string GetEndpointAddressForNamedEndpoint()
        {
            ServiceEndpointCollection endpointCollection;

            if (!ServiceEndpointCollection.TryParseEndpointsString(this.Endpoint.Address, out endpointCollection))
            {
                // Client has not specified an explicit name for the endpoint, so parse failure is ok.
                // return the endpoint address.
                if (this.ListenerName == null)
                {
                    return(this.Endpoint.Address);
                }
                else
                {
                    throw new FabricInvalidAddressException(
                              string.Format(
                                  CultureInfo.InvariantCulture,
                                  SR.ErrorInvalidPartitionEndpointAddress,
                                  this.Endpoint.Address,
                                  this.rsp.Info.Id));
                }
            }

            string parsedEndpointAddress;

            // Client has not specified a named endpoint, give the first endpoint in the collection.
            if (this.ListenerName == null)
            {
                if (endpointCollection.TryGetFirstEndpointAddress(out parsedEndpointAddress))
                {
                    return(parsedEndpointAddress);
                }
                else
                {
                    throw new FabricInvalidAddressException(
                              string.Format(
                                  CultureInfo.InvariantCulture,
                                  SR.ErrorInvalidPartitionEndpointAddress,
                                  this.Endpoint.Address,
                                  this.rsp.Info.Id));
                }
            }

            if (!endpointCollection.TryGetEndpointAddress(this.ListenerName, out parsedEndpointAddress))
            {
                throw new FabricInvalidAddressException(
                          string.Format(
                              CultureInfo.InvariantCulture,
                              SR.ErrorPartitionNamedEndpointNotFound,
                              this.ListenerName,
                              this.Endpoint.Address,
                              this.rsp.Info.Id));
            }

            return(parsedEndpointAddress);
        }
Exemple #5
0
 private void ImportMetadata(WsdlImporter wsdlImporter,
                             out ServiceEndpointCollection endpoints,
                             out Collection <System.ServiceModel.Channels.Binding> bindings,
                             out Collection <ContractDescription> contracts)
 {
     endpoints = wsdlImporter.ImportAllEndpoints();
     bindings  = wsdlImporter.ImportAllBindings();
     contracts = wsdlImporter.ImportAllContracts();
     ThrowOnMetadataConversionErrors(wsdlImporter.Errors);
 }
 /// <summary>
 /// Initializes a new instance of the <see cref="WcfServiceHostEventArgs" /> class.
 /// </summary>
 /// <param name="name">String of Wcf Service Name.</param>
 /// <param name="state">Instance of WcfServiceHostStateEnum.</param>
 /// <param name="endpoints">The endpoints.</param>
 /// <param name="channelMessage">The unit of communication between endpoints in a distributed environment.</param>
 /// <param name="message">The Wcf service message.</param>
 /// <param name="messageId">The message identifier.</param>
 /// <param name="isOneWay">Whether the message is one way.</param>
 public WcfServiceHostEventArgs(string name, WcfServiceHostState state, ServiceEndpointCollection endpoints, Message channelMessage, string message, Guid?messageId, bool?isOneWay)
 {
     this.Name           = name;
     this.Endpoints      = endpoints;
     this.State          = state;
     this.ChannelMessage = channelMessage;
     this.Message        = message;
     this.MessageId      = messageId ?? Guid.Empty;
     this.IsOneWay       = isOneWay;
 }
 internal ServiceDescription(string serviceName)
 {
     this.behaviors = new KeyedByTypeCollection<IServiceBehavior>();
     this.endpoints = new ServiceEndpointCollection();
     this.serviceNamespace = "http://tempuri.org/";
     if (string.IsNullOrEmpty(serviceName))
     {
         throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("serviceName");
     }
     this.Name = serviceName;
 }
Exemple #8
0
        static void Main()
        {
            // Specify the Metadata Exchange binding and its security mode
            WSHttpBinding mexBinding = new WSHttpBinding(SecurityMode.Message);

            mexBinding.Security.Message.ClientCredentialType = MessageCredentialType.Certificate;

            // Create a MetadataExchangeClient for retrieving metadata, and set the certificate details
            MetadataExchangeClient mexClient = new MetadataExchangeClient(mexBinding);

            mexClient.SoapCredentials.ClientCertificate.SetCertificate(
                StoreLocation.CurrentUser, StoreName.My,
                X509FindType.FindBySubjectName, "client.com");
            mexClient.SoapCredentials.ServiceCertificate.Authentication.CertificateValidationMode = X509CertificateValidationMode.PeerOrChainTrust;
            mexClient.SoapCredentials.ServiceCertificate.SetDefaultCertificate(
                StoreLocation.CurrentUser, StoreName.TrustedPeople,
                X509FindType.FindBySubjectName, "localhost");

            // The contract we want to fetch metadata for
            Collection <ContractDescription> contracts = new Collection <ContractDescription>();
            ContractDescription contract = ContractDescription.GetContract(typeof(ICalculator));

            contracts.Add(contract);

            // Find endpoints for that contract
            EndpointAddress           mexAddress = new EndpointAddress(ConfigurationManager.AppSettings["mexAddress"]);
            ServiceEndpointCollection endpoints  = MetadataResolver.Resolve(contracts,
                                                                            mexAddress, mexClient);

            // Communicate with each endpoint that supports the ICalculator contract.
            foreach (ServiceEndpoint endpoint in endpoints)
            {
                if (endpoint.Contract.Namespace.Equals(contract.Namespace) && endpoint.Contract.Name.Equals(contract.Name))
                {
                    // Create a channel and set the certificate details to communicate with the Application endpoint
                    ChannelFactory <ICalculator> cf = new ChannelFactory <ICalculator>(endpoint.Binding, endpoint.Address);
                    cf.Credentials.ClientCertificate.SetCertificate(StoreLocation.CurrentUser, StoreName.My,
                                                                    X509FindType.FindBySubjectName, "client.com");
                    cf.Credentials.ServiceCertificate.Authentication.CertificateValidationMode = X509CertificateValidationMode.PeerOrChainTrust;

                    ICalculator channel = cf.CreateChannel();

                    // call operations
                    DoCalculations(channel);

                    ((IChannel)channel).Close();
                    cf.Close();
                }
            }

            Console.WriteLine();
            Console.WriteLine("Press <ENTER> to terminate client.");
            Console.ReadLine();
        }
 public static void Trace(TraceEventType type, int traceCode, string description, ServiceInfo info, ServiceEndpointCollection endpointCollection)
 {
     if (DiagnosticUtility.ShouldTrace(type))
     {
         foreach (ServiceEndpoint endpoint in endpointCollection)
         {
             ComPlusServiceHostCreatedServiceEndpointSchema schema = new ComPlusServiceHostCreatedServiceEndpointSchema(info.AppID, info.Clsid, endpoint.Contract.Name, endpoint.Address.Uri, endpoint.Binding.Name);
             TraceUtility.TraceEvent(type, traceCode, System.ServiceModel.SR.GetString(description), (TraceRecord) schema);
         }
     }
 }
        private Dictionary <string, IEnumerable <ServiceEndpoint> > GetEndPointsOfEachServiceContract(WsdlImporter imptr, Collection <ContractDescription> svcCtrDescs)
        {
            ServiceEndpointCollection allEP = imptr.ImportAllEndpoints();
            var ctrEP = new Dictionary <string, IEnumerable <ServiceEndpoint> >();

            foreach (ContractDescription svcCtrDesc in svcCtrDescs)
            {
                List <ServiceEndpoint> eps = allEP.Where(x => x.Contract.Name == svcCtrDesc.Name).ToList();
                ctrEP.Add(svcCtrDesc.Name, eps);
            }
            return(ctrEP);
        }
Exemple #11
0
        private static void DumpEndpoint(ServiceEndpointCollection endpoints)
        {
            foreach (ServiceEndpoint sep in endpoints)
            {
                Console.Write("Address:{0}\nBinding:{1}\nContract:{2}\n", sep.Address, sep.Binding.Name, sep.Contract);
                Console.WriteLine("Binding Stack:");

                foreach (BindingElement be in sep.Binding.CreateBindingElements())
                {
                    Console.WriteLine(be.ToString());
                }
            }
        }
Exemple #12
0
        private static void DumpEndpoint(ServiceEndpointCollection endpoints)
        {
            foreach (ServiceEndpoint sep in endpoints)
            {
                Console.Write("Address:{0}\nBinding:{1}\nContract:{2}\n", sep.Address, sep.Binding.Name, sep.Contract);
                Console.WriteLine("Binding Stack:");

                foreach (BindingElement be in sep.Binding.CreateBindingElements())
                {
                    Console.WriteLine(be.ToString());
                }
            }
        }
        /// <summary>
        /// Gets all service endpoints for the contract interface type
        /// through the MEX exposed endpoint.
        /// </summary>
        /// <param name="contractType">The interface type contract of the service.</param>
        /// <param name="serviceEndpointAddress">The endpoint address of the service MEX.</param>
        /// <param name="mexMode">The metadata exchange client mode.</param>
        /// <returns>The collection of service endpoints.</returns>
        public static ServiceEndpointCollection GetServiceEndpoints(Type contractType,
                                                                    Uri serviceEndpointAddress, MetadataExchangeClientMode mexMode)
        {
            // Get all service endpoints for the current contract
            // at the specified service address, specifically get
            // the service information from the exposed
            // MEX (Metadata Exchange) endpoint address.
            ServiceEndpointCollection serviceEndpoints =
                MetadataResolver.Resolve(contractType, serviceEndpointAddress, mexMode);

            // Return the collection of endpoints.
            return(serviceEndpoints);
        }
 public static void Trace(TraceEventType type, int traceCode, string description, ServiceEndpointCollection serviceEndpointsRetrieved)
 {
     if (DiagnosticUtility.ShouldTrace(type))
     {
         int num = 0;
         ComPlusMexBuilderMetadataRetrievedEndpoint[] endpoints = new ComPlusMexBuilderMetadataRetrievedEndpoint[serviceEndpointsRetrieved.Count];
         foreach (ServiceEndpoint endpoint in serviceEndpointsRetrieved)
         {
             endpoints[num++] = new ComPlusMexBuilderMetadataRetrievedEndpoint(endpoint);
         }
         ComPlusMexBuilderMetadataRetrievedSchema schema = new ComPlusMexBuilderMetadataRetrievedSchema(endpoints);
         TraceUtility.TraceEvent(type, traceCode, System.ServiceModel.SR.GetString(description), (TraceRecord) schema);
     }
 }
Exemple #15
0
        /// <summary>
        /// Generates the service model endpoints for the metadata set in the xml file for the application configuration location.
        /// </summary>
        /// <param name="metaDocs">The metadata set document.</param>
        /// <param name="xmlFile">The name of the xml file to write the configuration information to.</param>
        /// <param name="configuration">The current application configuration file instance.</param>
        /// <returns>The collection of channel endpoint elements.</returns>
        public static ChannelEndpointElement[] GenerateServiceModelEndpoints(MetadataSet metaDocs,
                                                                             string xmlFile, System.Configuration.Configuration configuration)
        {
            // Make sure the page reference exists.
            if (metaDocs == null)
            {
                throw new ArgumentNullException("metaDocs");
            }
            if (xmlFile == null)
            {
                throw new ArgumentNullException("xmlFile");
            }
            if (configuration == null)
            {
                throw new ArgumentNullException("configuration");
            }

            WsdlImporter             importer  = new WsdlImporter(metaDocs);
            ServiceContractGenerator generator = new ServiceContractGenerator(configuration);

            // Get all the endpoint type bindings
            ServiceEndpointCollection serviceEndpoints = importer.ImportAllEndpoints();

            // Create a new endpoint collection.
            List <ChannelEndpointElement> endpointElements = new List <ChannelEndpointElement>();

            System.ServiceModel.Configuration.ChannelEndpointElement channelEndpoint = null;

            // For each endpoint found add the
            // type to the collection.
            foreach (ServiceEndpoint serviceEndpoint in serviceEndpoints)
            {
                generator.GenerateServiceEndpoint(serviceEndpoint, out channelEndpoint);
                endpointElements.Add(channelEndpoint);
            }

            // If no file has been specified then save to the application configuration
            // file else save to a new file specified.
            if (String.IsNullOrEmpty(xmlFile))
            {
                generator.Configuration.Save();
            }
            else
            {
                generator.Configuration.SaveAs(xmlFile);
            }

            // Return the collection of endpoints.
            return(endpointElements.ToArray());
        }
        public void Resolve3()
        {
            ContractDescription        contract  = ContractDescription.GetContract(typeof(IEchoService));
            List <ContractDescription> contracts = new List <ContractDescription> ();

            contracts.Add(contract);

            ServiceEndpointCollection endpoints = MetadataResolver.Resolve(
                contracts,
                new Uri(url),
                MetadataExchangeClientMode.MetadataExchange);

            CheckIEchoServiceEndpoint(endpoints);
        }
Exemple #17
0
    static void Main(string[] args)
    {
        Uri uri = new Uri("http://10.157.13.69:3336/mex");
        MetadataExchangeClient    client    = new MetadataExchangeClient(uri, MetadataExchangeClientMode.MetadataExchange);
        MetadataSet               metadata  = client.GetMetadata();
        WsdlImporter              importer  = new WsdlImporter(metadata);
        ServiceEndpointCollection endpoints = importer.ImportAllEndpoints();

        //ServiceEndpointCollection endpoints = MetadataResolver.Resolve(typeof(IService), uri, MetadataExchangeClientMode.MetadataExchange);
        foreach (var item in endpoints)
        {
            Console.WriteLine(item.Address.Uri);
        }
    }
Exemple #18
0
        /// <summary>
        /// Run test on all clients
        /// </summary>
        /// <typeparam name="TResult">Type name of the result value list</typeparam>
        /// <param name="asyncAction">Async action to run on all clients</param>
        /// <returns>Async task</returns>
        private async Task <TResult[]> RunOnAllClients <TResult>(Func <JobRunnerSvcClient, Task <TResult> > asyncAction)
        {
            var results = new List <TResult>();

            var serviceName   = this.serviceContext.ServiceName;
            var partitionList = await this.fabricClient.QueryManager.GetPartitionListAsync(serviceName).ConfigureAwait(false);

            foreach (var partition in partitionList)
            {
                var serviceReplicaList = await this.fabricClient.QueryManager.GetReplicaListAsync(partition.PartitionInformation.Id).ConfigureAwait(false);

                foreach (var replica in serviceReplicaList)
                {
                    if (!ServiceEndpointCollection.TryParseEndpointsString(replica.ReplicaAddress, out ServiceEndpointCollection endpoints))
                    {
                        VegaDistTestEventSource.Log.ParseEndpointsStringFailed(replica.ReplicaAddress);
                        continue;
                    }

                    if (!endpoints.TryGetEndpointAddress("GrpcEndpoint", out string jobControlEndpoint))
                    {
                        VegaDistTestEventSource.Log.GetEndpointAddressFailed("GrpcEndpoint", replica.ReplicaAddress);
                        continue;
                    }

                    Channel channel = null;
                    try
                    {
                        channel = new Channel(jobControlEndpoint.Replace(@"http://", string.Empty), ChannelCredentials.Insecure);
                        JobRunnerSvcClient client = new JobRunnerSvcClient(channel);

                        results.Add(await asyncAction(client).ConfigureAwait(false));
                    }
                    catch (Exception ex)
                    {
                        VegaDistTestEventSource.Log.RunJobOnClientFailed(jobControlEndpoint, ex.ToString());
                    }
                    finally
                    {
                        if (channel != null)
                        {
                            await channel.ShutdownAsync();
                        }
                    }
                }
            }

            return(results.ToArray());
        }
Exemple #19
0
        /// <summary>
        /// 根据Contract的名字查找EndPoint
        /// </summary>
        /// <param name="endpoints"></param>
        /// <param name="contractName"></param>
        /// <returns></returns>
        public static ServiceEndpoint FindByContractName(this ServiceEndpointCollection endpoints, string contractName)
        {
            ServiceEndpoint result = null;

            foreach (ServiceEndpoint endpoint in endpoints)
            {
                if (endpoint.Contract.ConfigurationName == contractName)
                {
                    result = endpoint;
                    break;
                }
            }

            return(result);
        }
Exemple #20
0
        /// <summary>
        /// Gets the first endpoint from the array of endpoints within a ResolvedServiceEndpoint.
        /// </summary>
        /// <param name="rse">ResolvedServiceEndpoint instance.</param>
        /// <returns>String containing the replica address.</returns>
        /// <exception cref="InvalidProgramException">ResolvedServiceEndpoint address list coudln't be parsed or no endpoints exist.</exception>
        public static string GetFirstEndpoint(this ResolvedServiceEndpoint rse)
        {
            ServiceEndpointCollection sec = null;

            if (ServiceEndpointCollection.TryParseEndpointsString(rse.Address, out sec))
            {
                string replicaAddress;
                if (sec.TryGetFirstEndpointAddress(out replicaAddress))
                {
                    return(replicaAddress);
                }
            }

            throw new InvalidProgramException("ResolvedServiceEndpoint had invalid address");
        }
Exemple #21
0
        private void AssertMetadataForWsHttp(MetadataSet metadata)
        {
            WsdlImporter importer = new WsdlImporter(metadata);
            Collection <ContractDescription> contracts = importer.ImportAllContracts();
            Collection <Binding>             bindings  = importer.ImportAllBindings();
            ServiceEndpointCollection        endpoints = importer.ImportAllEndpoints();

            Assert.IsTrue(metadata.MetadataSections.Count == 4 || metadata.MetadataSections.Count == 5);
            Assert.AreEqual(0, importer.Errors.Count);
            Assert.AreEqual(1, contracts.Count);
            Assert.AreEqual(1, bindings.Count);
            Assert.AreEqual(1, endpoints.Count);
            Assert.AreEqual("IMyService", contracts[0].Name);
            Assert.AreEqual(typeof(WSHttpBinding), bindings[0].GetType());
        }
        private void CheckIEchoServiceEndpoint(ServiceEndpointCollection endpoints)
        {
            Assert.IsNotNull(endpoints);
            Assert.AreEqual(1, endpoints.Count);

            ServiceEndpoint ep = endpoints [0];

            //URI Dependent
            //Assert.AreEqual ("http://localhost:8080/echo/svc", ep.Address.Uri.AbsoluteUri, "#R1");
            Assert.AreEqual("IEchoService", ep.Contract.Name, "#R3");
            Assert.AreEqual("http://myns/echo", ep.Contract.Namespace, "#R4");
            Assert.AreEqual("BasicHttpBinding_IEchoService", ep.Name, "#R5");

            Assert.AreEqual(typeof(BasicHttpBinding), ep.Binding.GetType(), "#R2");
        }
Exemple #23
0
        private void button1_Click(object sender, EventArgs e)
        {
            Uri uri = new Uri(textBox1.Text);
            ServiceEndpointCollection endpts = MetadataResolver.Resolve(typeof(IEmployeeService), uri, MetadataExchangeClientMode.HttpGet);

            foreach (ServiceEndpoint obj in endpts)
            {
                IEmployeeService proxy = new ChannelFactory <IEmployeeService>(obj.Binding, obj.Address).CreateChannel();
                DataSet          ds    = proxy.GetEmployees();
                listBox1.DataSource    = ds.Tables[0].DefaultView;
                listBox1.DisplayMember = "FirstName";
                listBox1.ValueMember   = "EmployeeID";
                ((IChannel)proxy).Close();
            }
        }
Exemple #24
0
        async Task <string> IStatefulServiceReplica.ChangeRoleAsync(ReplicaRole newRole, CancellationToken cancellationToken)
        {
            ServiceTrace.Source.WriteInfoWithId(
                TraceType,
                this.traceId,
                "ChangeRoleAsync : new role {0}",
                newRole);

            await this.CloseCommunicationListenersAsync(cancellationToken);

            if (newRole == ReplicaRole.Primary)
            {
                this.endpointCollection = await this.OpenCommunicationListenersAsync(newRole, cancellationToken);

                this.userServiceReplica.Addresses = this.endpointCollection.ToReadOnlyDictionary();

                this.runAsynCancellationTokenSource = new CancellationTokenSource();
                this.executeRunAsyncTask            = this.ScheduleRunAsync(this.runAsynCancellationTokenSource.Token);
            }
            else
            {
                await this.CancelRunAsync();

                if (newRole == ReplicaRole.ActiveSecondary)
                {
                    this.endpointCollection = await this.OpenCommunicationListenersAsync(newRole, cancellationToken);

                    this.userServiceReplica.Addresses = this.endpointCollection.ToReadOnlyDictionary();
                }
            }

            ServiceTrace.Source.WriteInfoWithId(
                TraceType,
                this.traceId,
                "ChangeRoleAsync : Begin UserServiceReplica change role to {0}",
                newRole);

            await this.userServiceReplica.OnChangeRoleAsync(newRole, cancellationToken);

            ServiceTrace.Source.WriteInfoWithId(
                TraceType,
                this.traceId,
                "ChangeRoleAsync : End UserServiceReplica change role");

            await this.stateProviderReplica.ChangeRoleAsync(newRole, cancellationToken);

            return(this.endpointCollection.ToString());
        }
Exemple #25
0
        public static string[] GetAddresses(string mexAddress, string contractNamespace, string contractName)
        {
            ServiceEndpointCollection endpoints = GetEndpoints(mexAddress);

            List <string> addresses = new List <string>();

            foreach (ServiceEndpoint endpoint in endpoints)
            {
                if (endpoint.Contract.Namespace == contractNamespace && endpoint.Contract.Name == contractName)
                {
                    Debug.Assert(addresses.Contains(endpoint.Address.Uri.AbsoluteUri) == false);
                    addresses.Add(endpoint.Address.Uri.AbsoluteUri);
                }
            }
            return(addresses.ToArray());
        }
Exemple #26
0
        static void Main(string[] args)
        {
            ServiceEndpointCollection serviceEndpointCollection =
                MetadataResolver.Resolve(typeof(IMachine),
                                         new EndpointAddress("http://localhost:8080/ServiceMachine/mex"));

            foreach (var endpoint in serviceEndpointCollection)
            {
                var    channel     = new MachineClient(endpoint.Binding, endpoint.Address);
                string machineName = channel.GetMachineName(new MachineDTO {
                    MachineID = "1", MachineName = "test"
                });
                Console.WriteLine(machineName);
                Console.WriteLine(endpoint.Binding);
            }
        }
Exemple #27
0
        /// <summary>
        /// Queries the mex endpoint via HTTP get.
        /// </summary>
        /// <param name="mexAddress">The mex address.</param>
        /// <param name="bindingElement">The binding element.</param>
        /// <returns>ServiceEndpointCollection.</returns>
        private static ServiceEndpointCollection QueryMexEndpointViaHttpGet(string mexAddress, TransportBindingElement bindingElement)
        {
            ServiceEndpointCollection endpoints = null;

            if (mexAddress.EndsWith("?wsdl") == false)
            {
                mexAddress += "?wsdl";
            }
            var binding   = new CustomBinding(bindingElement);
            var mexClient = new MetadataExchangeClient(binding);
            var metadata  = mexClient.GetMetadata(new Uri(mexAddress), MetadataExchangeClientMode.HttpGet);
            var importer  = new WsdlImporter(metadata);

            endpoints = importer.ImportAllEndpoints();
            return(endpoints);
        }
Exemple #28
0
        public static void Snippet2()
        {
            using (ServiceHost serviceHost = new ServiceHost(typeof(CalculatorService)))
            {
                serviceHost.Open();
                ServiceEndpointCollection endpoints = serviceHost.Description.Endpoints;
                ServiceEndpoint           endpoint  = endpoints.Find(typeof(ICalculator));

                NetTcpBinding binding = (NetTcpBinding)endpoint.Binding;

                // <Snippet2>
                NetTcpSecurity security = binding.Security;
                Console.WriteLine("\tSecurity Mode: {0}", security.Mode);
                // </Snippet2>
            }
        }
 ServiceEndpointCollection ImportWsdlPortType(XmlQualifiedName portTypeQName, WsdlImporter importer)
 {
     foreach (WsdlNS.ServiceDescription wsdl in importer.WsdlDocuments)
     {
         if (wsdl.TargetNamespace == portTypeQName.Namespace)
         {
             WsdlNS.PortType wsdlPortType = wsdl.PortTypes[portTypeQName.Name];
             if (wsdlPortType != null)
             {
                 ServiceEndpointCollection endpoints = importer.ImportEndpoints(wsdlPortType);
                 return(endpoints);
             }
         }
     }
     return(new ServiceEndpointCollection());
 }
Exemple #30
0
        static void Main(string[] args)
        {
            EndpointAddress           metaAddress = new EndpointAddress(new Uri("http://localhost:1169/Service1.svc/mex"));
            ServiceEndpointCollection endpoints   = MetadataResolver.Resolve(typeof(IService1), metaAddress);

            foreach (ServiceEndpoint point in endpoints)
            {
                if (point != null)
                {
                    using (Service1Client wcfClient = new Service1Client(point.Binding, point.Address))
                    {
                        Console.WriteLine(wcfClient.GetString(String.Format("binding is {0}, address is {1}", point.Binding, point.Address)));
                    }
                }
            }
            Console.ReadLine();
        }
Exemple #31
0
    Binding DiscoverBinding <T>()
    {
        Binding binding = null;

        DiscoveryClient discoveryClient = new DiscoveryClient(new UdpDiscoveryEndpoint());
        FindResponse    discovered      = discoveryClient.Find(FindCriteria.CreateMexEndpointCriteria());

        foreach (EndpointDiscoveryMetadata mexEndpoint in discovered.Endpoints)
        {
            Debug.Assert(binding == null);

            ServiceEndpointCollection endpoints = MetadataResolver.Resolve(typeof(IMyContract), mexEndpoint.Address.Uri, MetadataExchangeClientMode.MetadataExchange);
            Debug.Assert(endpoints.Count == 1);

            binding = endpoints[0].Binding;
        }
        return(binding);
    }
Exemple #32
0
    private DestinationConfig BuildDestination(ReplicaWrapper replica, string listenerName, string healthListenerName, PartitionWrapper partition)
    {
        if (!ServiceEndpointCollection.TryParseEndpointsString(replica.ReplicaAddress, out var serviceEndpointCollection))
        {
            throw new ConfigException($"Could not parse endpoints for replica {replica.Id}.");
        }

        // TODO: FabricServiceEndpoint has some other fields we are ignoring here. Decide which ones are relevant and fix this call.
        var serviceEndpoint = new FabricServiceEndpoint(
            listenerNames: new[] { listenerName },
            allowedSchemePredicate: HttpsSchemeSelector,
            emptyStringMatchesAnyListener: true);
        if (!FabricServiceEndpointSelector.TryGetEndpoint(serviceEndpoint, serviceEndpointCollection, out var endpointUri))
        {
            throw new ConfigException($"No acceptable endpoints found for replica '{replica.Id}'. Search criteria: listenerName='{listenerName}', emptyStringMatchesAnyListener=true.");
        }

        // Get service endpoint from the health listener, health listener is optional.
        Uri healthEndpointUri = null;
        if (!string.IsNullOrEmpty(healthListenerName))
        {
            var healthEndpoint = new FabricServiceEndpoint(
                listenerNames: new[] { healthListenerName },
                allowedSchemePredicate: HttpsSchemeSelector,
                emptyStringMatchesAnyListener: true);
            if (!FabricServiceEndpointSelector.TryGetEndpoint(healthEndpoint, serviceEndpointCollection, out healthEndpointUri))
            {
                throw new ConfigException($"No acceptable health endpoints found for replica '{replica.Id}'. Search criteria: listenerName='{healthListenerName}', emptyStringMatchesAnyListener=true.");
            }
        }

        return new DestinationConfig
        {
            Address = endpointUri.AbsoluteUri,
            Health = healthEndpointUri?.AbsoluteUri,
            Metadata = new Dictionary<string, string>
            {
                { "PartitionId", partition.Id.ToString() ?? string.Empty },
                { "NamedPartitionName", partition.Name ?? string.Empty },
                { "ReplicaId", replica.Id.ToString() ?? string.Empty }
            }
        };
    }
Exemple #33
0
        private void listBox1_Click(object sender, EventArgs e)
        {
            //Comment one of the URLs
            //Uri uri = new Uri("http://localhost:8000/EmployeeService?wsdl");
            //Uri uri = new Uri("http://Localhost/EmployeeServiceHostWeb/EmployeeServicerHost.svc?wsdl");

            Uri uri = new Uri(textBox1.Text);
            ServiceEndpointCollection endpts = MetadataResolver.Resolve(typeof(IEmployeeService), uri, MetadataExchangeClientMode.HttpGet);

            foreach (ServiceEndpoint obj in endpts)
            {
                IEmployeeService proxy = new ChannelFactory <IEmployeeService>(obj.Binding, obj.Address).CreateChannel();
                Employee         emp   = proxy.GetEmployee(int.Parse(listBox1.SelectedValue.ToString()));
                label5.Text = emp.EmployeeID.ToString();
                label6.Text = emp.FirstName;
                label7.Text = emp.LastName;
                ((IChannel)proxy).Close();
            }
        }
        internal StatelessServiceInstanceAdapter(
            StatelessServiceContext context,
            IStatelessUserServiceInstance userServiceInstance)
        {
            this.serviceContext = context;
            this.traceId        = ServiceTrace.GetTraceIdForReplica(context.PartitionId, context.InstanceId);
            this.serviceHelper  = new ServiceHelper(TraceType, this.traceId);

            this.servicePartition       = null;
            this.instanceListeners      = null;
            this.communicationListeners = null;
            this.endpointCollection     = new ServiceEndpointCollection();

            this.runAsynCancellationTokenSource = null;
            this.executeRunAsyncTask            = null;

            this.userServiceInstance           = userServiceInstance;
            this.userServiceInstance.Addresses = this.endpointCollection.ToReadOnlyDictionary();
        }
        private static ServiceEndpointCollection ImportEndpoints(MetadataSet metadataSet, IEnumerable<ContractDescription> contracts, MetadataExchangeClient client)
        {
            ServiceEndpointCollection endpoints = new ServiceEndpointCollection();

            WsdlImporter importer = new WsdlImporter(metadataSet);

            // remember the original proxy so user doesn't need to set it again 
            importer.State.Add(MetadataExchangeClient.MetadataExchangeClientKey, client);

            foreach (ContractDescription cd in contracts)
            {
                importer.KnownContracts.Add(WsdlExporter.WsdlNamingHelper.GetPortTypeQName(cd), cd);
            }

            foreach (ContractDescription cd in contracts)
            {
                ServiceEndpointCollection contractEndpoints;
                contractEndpoints = importer.ImportEndpoints(cd);
                foreach (ServiceEndpoint se in contractEndpoints)
                {
                    endpoints.Add(se);
                }
            }

            //Trace all warnings and errors
            if (importer.Errors.Count > 0)
            {
                TraceWsdlImportErrors(importer);
            }

            return endpoints;
        }
        private void GenerateConfig(
            ServiceContractGenerator contractGenerator, 
            ServiceEndpointCollection endpoints)
        {
			List<string> addedEndpoints = new List<string>();
            foreach (ServiceEndpoint endpoint in endpoints)
            {
                // filter by endpoint address so we generate only the endpoint 
                // that matches the endpoint names in ImportedEndpointNames
                if (!addedEndpoints.Contains(endpoint.Name) &&
					(options.ImportedEndpointNames.Count == 0 ||
                     options.ImportedEndpointNames.Contains(endpoint.Name)))
                {
                    // generate service endpoint
                    ChannelEndpointElement channelElement;
                    contractGenerator.GenerateServiceEndpoint(endpoint, out channelElement);
                    this.generatedChannelElements.Add(channelElement);
                    // generate the binding
                    string bindingSectionName;
                    string configurationName;
                    contractGenerator.GenerateBinding(endpoint.Binding, out bindingSectionName, out configurationName);
                    ThrowOnMetadataConversionErrors(contractGenerator.Errors);
					addedEndpoints.Add(endpoint.Name);
                }
            }

            // Save changes if specified.
            if (!string.IsNullOrEmpty(options.OutputConfigurationFile))
            {
                configuration.Save(ConfigurationSaveMode.Modified);
            }
        }
Exemple #37
0
		public override ServiceEndpointCollection ImportAllEndpoints ()
		{
			if (endpoint_colln != null)
				return endpoint_colln;

			endpoint_colln = new ServiceEndpointCollection ();

			foreach (WSServiceDescription wsd in wsdl_documents) {
				foreach (Service service in wsd.Services) {
					foreach (Port port in service.Ports) {
						var sep = ImportEndpoint (port, false);
						if (sep != null)
							endpoint_colln.Add (sep);
					}
				}
			}

			return endpoint_colln;
		}
Exemple #38
0
 void ProcessMetaData(ServiceEndpointCollection endpoints)
 {
    if(endpoints.Count == 0)
    {
       m_Root = new ServiceNode(this,"Service has no endpoints",ServiceIndex,ServiceIndex);
       m_MexTree.Nodes.Add(m_Root);
       return;
    }
    else
    {
       m_Root = new ServiceNode(this,"Exploring...",ServiceIndex,ServiceIndex);
       m_MexTree.Nodes.Add(m_Root);
    }
    int index = 1;
    foreach(ServiceEndpoint endpoint in endpoints)
    {
       AddEndPoint(endpoint,"Endpoint"+index);
       index++;
    }
    DisplayServiceControl();
 }
		private static ServiceEndpointCollection ResolveContracts (
				IEnumerable<ContractDescription> contracts,
				Func<MetadataSet> metadataGetter)
		{
			if (contracts == null)
				throw new ArgumentNullException ("contracts");

			List<ContractDescription> list = new List<ContractDescription> (contracts);
			if (list.Count == 0)
				throw new ArgumentException ("There must be atleast one ContractDescription", "contracts");

			MetadataSet metadata = metadataGetter ();
			WsdlImporter importer = new WsdlImporter (metadata);
			ServiceEndpointCollection endpoints = importer.ImportAllEndpoints ();
			
			ServiceEndpointCollection ret = new ServiceEndpointCollection ();

			foreach (ContractDescription contract in list) {
				Collection<ServiceEndpoint> colln = 
					endpoints.FindAll (new QName (contract.Name, contract.Namespace));

				for (int i = 0; i < colln.Count; i ++)
					ret.Add (colln [i]);
			}

			return ret;
		}
Exemple #40
0
		void ImportEndpoints (ServiceEndpointCollection coll, WSBinding binding)
		{
			foreach (WSServiceDescription wsd in wsdl_documents) {
				foreach (WS.Service service in wsd.Services) {
					foreach (WS.Port port in service.Ports) {
						if (!binding.Name.Equals (port.Binding.Name))
							continue;
						var sep = ImportEndpoint (port, false);
						if (sep != null)
							coll.Add (sep);
					}
				}
			}
		}
Exemple #41
0
		public ServiceEndpointCollection ImportEndpoints (WSBinding binding)
		{
			var coll = new ServiceEndpointCollection ();
			ImportEndpoints (coll, binding);
			return coll;
		}
            void AddCompatibleFederationEndpoints(ServiceEndpointCollection serviceEndpoints, IssuedSecurityTokenParameters parameters)
            {
                // check if an explicit issuer address has been specified. If so,add the endpoint corresponding to that address only. If not add all acceptable endpoints.

                bool isIssuerSpecified = (parameters.IssuerAddress != null && !parameters.IssuerAddress.IsAnonymous);
                foreach (ServiceEndpoint endpoint in serviceEndpoints)
                {
                    TrustDriver trustDriver;
                    if (!TryGetTrustDriver(endpoint, out trustDriver))
                    {
                        // if endpoint does not have trustDriver, assume
                        // parent trustDriver.
                        trustDriver = this.trustDriver;
                    }
                    bool isFederationContract = false;
                    ContractDescription contract = endpoint.Contract;
                    for (int j = 0; j < contract.Operations.Count; ++j)
                    {
                        OperationDescription operation = contract.Operations[j];
                        bool hasIncomingRst = false;
                        bool hasOutgoingRstr = false;
                        for (int k = 0; k < operation.Messages.Count; ++k)
                        {
                            MessageDescription message = operation.Messages[k];
                            if (message.Action == trustDriver.RequestSecurityTokenAction.Value && message.Direction == MessageDirection.Input)
                            {
                                hasIncomingRst = true;
                            }
                            else if ((((trustDriver.StandardsManager.TrustVersion == TrustVersion.WSTrustFeb2005) && (message.Action == trustDriver.RequestSecurityTokenResponseAction.Value)) || 
                                ((trustDriver.StandardsManager.TrustVersion == TrustVersion.WSTrust13) && (message.Action == trustDriver.RequestSecurityTokenResponseFinalAction.Value))) && 
                                message.Direction == MessageDirection.Output)
                            {
                                hasOutgoingRstr = true;
                            }
                        }
                        if (hasIncomingRst && hasOutgoingRstr)
                        {
                            isFederationContract = true;
                            break;
                        }
                    }
                    if (isFederationContract)
                    {
                        // skip if it is not an acceptable endpoint
                        if (isIssuerSpecified && !parameters.IssuerAddress.Uri.Equals(endpoint.Address.Uri))
                        {
                            continue;
                        }

                        if (parameters.IssuerBinding == null)
                        {
                            parameters.IssuerAddress = endpoint.Address;
                            parameters.IssuerBinding = endpoint.Binding;
                        }
                        else
                        {
                            IssuedSecurityTokenParameters.AlternativeIssuerEndpoint endpointInfo = new IssuedSecurityTokenParameters.AlternativeIssuerEndpoint();
                            endpointInfo.IssuerAddress = endpoint.Address;
                            endpointInfo.IssuerBinding = endpoint.Binding;
                            parameters.AlternativeIssuerEndpoints.Add(endpointInfo);
                        }
                    }
                }
            }
 private static ServiceEndpointCollection ImportEndpoints(MetadataSet metadataSet, IEnumerable<ContractDescription> contracts, MetadataExchangeClient client)
 {
     ServiceEndpointCollection endpoints = new ServiceEndpointCollection();
     WsdlImporter importer = new WsdlImporter(metadataSet);
     importer.State.Add("MetadataExchangeClientKey", client);
     foreach (ContractDescription description in contracts)
     {
         importer.KnownContracts.Add(WsdlExporter.WsdlNamingHelper.GetPortTypeQName(description), description);
     }
     foreach (ContractDescription description2 in contracts)
     {
         foreach (ServiceEndpoint endpoint in importer.ImportEndpoints(description2))
         {
             endpoints.Add(endpoint);
         }
     }
     if (importer.Errors.Count > 0)
     {
         TraceWsdlImportErrors(importer);
     }
     return endpoints;
 }
Exemple #44
0
		public ServiceEndpointCollection ImportEndpoints (PortType portType)
		{
			var coll = new ServiceEndpointCollection ();

			foreach (WSServiceDescription wsd in wsdl_documents) {
				foreach (WS.Binding binding in wsd.Bindings) {
					if (!binding.Type.Name.Equals (portType.Name))
						continue;

					ImportEndpoints (coll, binding);
				}
			}

			return coll;
		}
 private void HandleResult(IAsyncResult result)
 {
     MetadataSet metadataSet = this.client.EndGetMetadata(result);
     this.endpointCollection = MetadataResolver.ImportEndpoints(metadataSet, this.knownContracts, this.client);
 }
Exemple #46
0
		public ServiceEndpointCollection ImportEndpoints (Service service)
		{
			var coll = new ServiceEndpointCollection ();
			
			foreach (Port port in service.Ports) {
				var sep = ImportEndpoint (port, false);
				if (sep != null)
					coll.Add (sep);
			}

			return coll;
		}
Exemple #47
0
 void ProcessMetaData(ServiceNode existingNode,string mexAddress,ServiceEndpointCollection endpoints)
 {
    ProcessMetaData(existingNode,mexAddress,endpoints.ToArray());
 }
 private void ImportMetadata(WsdlImporter wsdlImporter,
     out ServiceEndpointCollection endpoints, 
     out Collection<System.ServiceModel.Channels.Binding> bindings, 
     out Collection<ContractDescription> contracts)
 {
     endpoints = wsdlImporter.ImportAllEndpoints();
     bindings = wsdlImporter.ImportAllBindings();
     contracts = wsdlImporter.ImportAllContracts();
     ThrowOnMetadataConversionErrors(wsdlImporter.Errors);
 }
		public override ServiceEndpointCollection ImportAllEndpoints ()
		{
			if (endpoint_colln != null)
				return endpoint_colln;

			endpoint_colln = new ServiceEndpointCollection ();

			foreach (IWsdlImportExtension extension in wsdl_extensions) {
				extension.BeforeImport (wsdl_documents, xmlschemas, policies);
			}

			foreach (WSServiceDescription wsd in wsdl_documents)
				foreach (Service service in wsd.Services)
					foreach (Port port in service.Ports)
						endpoint_colln.Add (ImportEndpoint (port));

			return endpoint_colln;
		}
 public ServiceDescription()
 {
     this.behaviors = new KeyedByTypeCollection<IServiceBehavior>();
     this.endpoints = new ServiceEndpointCollection();
     this.serviceNamespace = "http://tempuri.org/";
 }
        private void ImportMetadata()
        {
            this.codeCompileUnit = new CodeCompileUnit();
            CreateCodeDomProvider();

            WsdlImporter importer = new WsdlImporter(new MetadataSet(metadataCollection));
            AddStateForDataContractSerializerImport(importer);
            AddStateForXmlSerializerImport(importer);

            this.bindings = importer.ImportAllBindings();
            this.contracts = importer.ImportAllContracts();
            this.endpoints = importer.ImportAllEndpoints();
            this.importWarnings = importer.Errors;

            bool success = true;
            if (this.importWarnings != null)
            {
                foreach (MetadataConversionError error in this.importWarnings)
                {
                    if (!error.IsWarning)
                    {
                        success = false;
                        break;
                    }
                }
            }

            if (!success)
            {
                DynamicProxyException exception = new DynamicProxyException(
                    Constants.ErrorMessages.ImportError);
                exception.MetadataImportErrors = this.importWarnings;
                throw exception;
            }
        }
		private void CheckIEchoServiceEndpoint (ServiceEndpointCollection endpoints)
		{
			Assert.IsNotNull (endpoints);
			Assert.AreEqual (1, endpoints.Count);

			ServiceEndpoint ep = endpoints [0];

			//URI Dependent
			//Assert.AreEqual ("http://localhost:8080/echo/svc", ep.Address.Uri.AbsoluteUri, "#R1");
			Assert.AreEqual ("IEchoService", ep.Contract.Name, "#R3");
			Assert.AreEqual ("http://myns/echo", ep.Contract.Namespace, "#R4");
			Assert.AreEqual ("BasicHttpBinding_IEchoService", ep.Name, "#R5");

			Assert.AreEqual (typeof (BasicHttpBinding), ep.Binding.GetType (), "#R2");
		}
 private void AddCompatibleFederationEndpoints(ServiceEndpointCollection serviceEndpoints, IssuedSecurityTokenParameters parameters)
 {
     bool flag = (parameters.IssuerAddress != null) && !parameters.IssuerAddress.IsAnonymous;
     foreach (ServiceEndpoint endpoint in serviceEndpoints)
     {
         TrustDriver trustDriver;
         if (!this.TryGetTrustDriver(endpoint, out trustDriver))
         {
             trustDriver = this.trustDriver;
         }
         bool flag2 = false;
         ContractDescription contract = endpoint.Contract;
         for (int i = 0; i < contract.Operations.Count; i++)
         {
             OperationDescription description2 = contract.Operations[i];
             bool flag3 = false;
             bool flag4 = false;
             for (int j = 0; j < description2.Messages.Count; j++)
             {
                 MessageDescription description3 = description2.Messages[j];
                 if ((description3.Action == trustDriver.RequestSecurityTokenAction.Value) && (description3.Direction == MessageDirection.Input))
                 {
                     flag3 = true;
                 }
                 else if ((((trustDriver.StandardsManager.TrustVersion == TrustVersion.WSTrustFeb2005) && (description3.Action == trustDriver.RequestSecurityTokenResponseAction.Value)) || ((trustDriver.StandardsManager.TrustVersion == TrustVersion.WSTrust13) && (description3.Action == trustDriver.RequestSecurityTokenResponseFinalAction.Value))) && (description3.Direction == MessageDirection.Output))
                 {
                     flag4 = true;
                 }
             }
             if (flag3 && flag4)
             {
                 flag2 = true;
                 break;
             }
         }
         if (flag2 && (!flag || parameters.IssuerAddress.Uri.Equals(endpoint.Address.Uri)))
         {
             if (parameters.IssuerBinding == null)
             {
                 parameters.IssuerAddress = endpoint.Address;
                 parameters.IssuerBinding = endpoint.Binding;
             }
             else
             {
                 IssuedSecurityTokenParameters.AlternativeIssuerEndpoint item = new IssuedSecurityTokenParameters.AlternativeIssuerEndpoint {
                     IssuerAddress = endpoint.Address,
                     IssuerBinding = endpoint.Binding
                 };
                 parameters.AlternativeIssuerEndpoints.Add(item);
             }
         }
     }
 }