public async Task EventTest()
{
var route1 = new ServiceRoute
{
Address = new[]
{
new IpAddressModel("127.0.0.1", 1)
},
ServiceDescriptor = new ServiceDescriptor
{
Id = "service1"
}
};
var route2 = new ServiceRoute
{
Address = new[]
{
new IpAddressModel("127.0.0.1", 2)
},
ServiceDescriptor = new ServiceDescriptor
{
Id = "service2"
}
};
var route3 = new ServiceRoute
{
Address = new[]
{
new IpAddressModel("127.0.0.1", 3)
},
ServiceDescriptor = new ServiceDescriptor
{
Id = "service3"
}
};
await ServiceRouteManager.ClearAsync();
await Task.Delay(2000);
var initWait = new TaskCompletionSource <bool>();
ServiceRouteManager.Created += (s, e) => { initWait.TrySetResult(true); };
await ServiceRouteManager.SetRoutesAsync(new[] { route1, route2 });
await initWait.Task;
await Task.Delay(2000);
route2.Address = new[]
{
new IpAddressModel("127.0.0.1", 11)
};
TaskCompletionSource <bool> createdWait = null, changedWait = null, removedWait = null;
Action reset = () =>
{
createdWait = new TaskCompletionSource <bool>();
changedWait = new TaskCompletionSource <bool>();
removedWait = new TaskCompletionSource <bool>();
};
reset();
ServiceRouteManager.Created += (s, e) => { createdWait.TrySetResult(route3.ServiceDescriptor.Id == e.Route.ServiceDescriptor.Id); };
ServiceRouteManager.Changed += (s, e) => {
changedWait.TrySetResult(
route2.ServiceDescriptor.Id == e.Route.ServiceDescriptor.Id &&
route2.Address.First() == e.Route.Address.First() &&
2 == ((IpAddressModel)e.OldRoute.Address.First()).Port);
};
ServiceRouteManager.Removed += (s, e) => { removedWait.TrySetResult(route1.ServiceDescriptor.Id == e.Route.ServiceDescriptor.Id); };
await ServiceRouteManager.SetRoutesAsync(new[] { route2, route3 });
Assert.True(await createdWait.Task);
Assert.True(await changedWait.Task);
Assert.True(await removedWait.Task);
}
public RouteStationListManager(ServiceRoute route)
{
InitializeComponent();
}
public ActionResult SaveServiceRoute(ServiceRoute model)
{
var data = BusinessAccessLayer.BALSupport.BALSaveServiceRoute(model);
return(Json(data, JsonRequestBehavior.AllowGet));
}
public IServiceEntryContainer AddServices(Type[] types)
{
IEnumerable <Type> serviceTypes = types
.Where(x => x.GetMethods().Any(y => y.GetCustomAttribute <ServiceAttribute>() != null)).Distinct();
foreach (Type type in serviceTypes)
{
ServiceRouteAttribute routeTemplate = type.GetCustomAttribute <ServiceRouteAttribute>();
ServiceVersionAttribute version = type.GetCustomAttribute <ServiceVersionAttribute>();
foreach (MethodInfo methodInfo in type.GetTypeInfo().GetMethods().Where(x => x.GetCustomAttributes <ServiceDescAttribute>().Any()))
{
ServiceDesc desc = new ServiceDesc();
IEnumerable <ServiceDescAttribute> descriptorAttributes = methodInfo.GetCustomAttributes <ServiceDescAttribute>();
IEnumerable <FilterBaseAttribute> filters = methodInfo.GetCustomAttributes <FilterBaseAttribute>();
foreach (ServiceDescAttribute attr in descriptorAttributes)
{
attr.Apply(desc);
}
desc.ReturnDesc = GetReturnDesc(methodInfo);
if (string.IsNullOrEmpty(desc.HttpMethod))
{
desc.HttpMethod = GetHttpMethod(methodInfo);
}
desc.Parameters = _serializer.Serialize <string>(GetParameters(methodInfo));
string route = string.Empty;
if (routeTemplate != null)
{
if (version != null && routeTemplate.RouteTemplate.Contains("{version}"))
{
route = routeTemplate.RouteTemplate.Replace("{version}", version.Version);
desc.Version = version.Version;
}
else
{
route = routeTemplate.RouteTemplate;
}
}
if (string.IsNullOrEmpty(desc.Id))
{
desc.Id = _serviceIdGenerate.GenerateServiceId(methodInfo, route, desc).ToLower();
}
FastExecutor.FastExecutorHandler fastInvoker = GetHandler(desc.Id, methodInfo);
ParameterInfo[] methodParas = methodInfo.GetParameters();
if (routeTemplate != null)
{
desc.RoutePath = ServiceRoute.ParseRoutePath(route, type.Name, methodInfo.Name, methodParas, type.IsInterface);
}
ServiceEntry service = new ServiceEntry
{
Descriptor = desc,
Parameters = methodParas,
Func = (context) =>
{
object instance = GetInstance(methodInfo.DeclaringType, context.RemoteInvokeMessage.Payload);
Dictionary <Type, object> dic = new Dictionary <Type, object>();
foreach (ParameterInfo p in methodParas)
{
context.RemoteInvokeMessage.Parameters.TryGetValue(p.Name.ToLower(), out object value);
object parameter;
Type paraType = p.ParameterType;
if (typeof(List <ServerFile>) == paraType)
{
List <FileData> fileData = _typeConvertProvider.Convert(value, paraType) as List <FileData>;
List <ServerFile> files = new List <ServerFile>();
foreach (FileData file in fileData)
{
ServerFile serverFile = new ServerFile
{
Data = Convert.FromBase64String(file.Data),
FileName = file.FileName
};
files.Add(serverFile);
}
parameter = files;
}
else
{
parameter = _typeConvertProvider.Convert(value, paraType) ?? null;
}
dic[paraType] = parameter;
}
FilterContext filterContext = new FilterContext()
{
Payload = context.RemoteInvokeMessage.Payload,
Descriptor = desc,
ServiceArguments = dic
};
filters?.Aggregate(filterContext, (filtercontext, filter) =>
{
filter.Container = _container;
if (filtercontext.Result == null)
{
filter.OnActionExecuting(filtercontext);
}
return(filtercontext);
});
if (filterContext.Result == null)
{
filterContext.Result = fastInvoker(instance, dic.Select(o => o.Value).ToArray());
filters?.Aggregate(filterContext, (filtercontext, filter) =>
{
filter.OnActionExecuted(filtercontext);
return(filtercontext);
});
}
return(Task.FromResult(filterContext.Result));
}
};
_services.Add(service);
}
}
return(this);
}
protected override async Task RemveAddressAsync(IEnumerable <AddressModel> address, ServiceRoute serviceRoute)
{
serviceRoute.Address = serviceRoute.Address.Except(address).ToList();
var clients = await _consulClientProvider.GetClients();
foreach (var client in clients)
{
await SetRouteAsync(CreateServiceRouteDescriptor(serviceRoute), client);
}
}
public ServiceRouteChangedEventArgs(ServiceRoute route, ServiceRoute oldRoute) : base(route)
{
OldRoute = oldRoute;
}
private bool GetAllowRequest(ServiceRoute route)
{
return(!route.ServiceDescriptor.DisableNetwork());
}
private async Task<IEnumerable<ServiceRoute>> GetRoutes(string file)
{
ServiceRoute[] routes;
if (File.Exists(file))
{
if (_logger.IsEnabled(LogLevel.Debug))
_logger.LogDebug($"准备从文件：{file}中获取服务路由。");
string content;
while (true)
{
try
{
using (
var fileStream = new FileStream(file, FileMode.Open, FileAccess.Read, FileShare.ReadWrite))
{
var reader = new StreamReader(fileStream, Encoding.UTF8);
content = await reader.ReadToEndAsync();
}
break;
}
catch (IOException)
{
}
}
try
{
var serializer = _serializer;
routes =
(await
_serviceRouteFactory.CreateServiceRoutesAsync(
serializer.Deserialize<string, ServiceRouteDescriptor[]>(content))).ToArray();
if (_logger.IsEnabled(LogLevel.Information))
_logger.LogInformation(
$"成功获取到以下路由信息：{string.Join(",", routes.Select(i => i.ServiceDescriptor.Id))}。");
}
catch (Exception exception)
{
if (_logger.IsEnabled(LogLevel.Error))
_logger.LogError("获取路由信息时发生了错误。", exception);
routes = new ServiceRoute[0];
}
}
else
{
if (_logger.IsEnabled(LogLevel.Warning))
_logger.LogWarning($"无法获取路由信息，因为文件：{file}不存在。");
routes = new ServiceRoute[0];
}
return routes;
}
public static List <ServiceRoute> BALSaveServiceRoute(ServiceRoute model)
{
return(SupportingRepository.SaveServiceRoute(model).ToList());
}
internal static void DeploySsbObj(object obj, string svrName, string dbName, SsbEnum ssbType, bool isEdit)
{
Server svr = CreateServer(svrName, null, null);
Database db = svr.Databases[dbName];
ServiceBroker sb = db.ServiceBroker;
MessageType mt = null;
ServiceContract sc = null;
ServiceQueue q = null;
BrokerService serv = null;
ServiceRoute rt = null;
RemoteServiceBinding bind = null;
try {
switch (ssbType)
{
case SsbEnum.MessageType:
MessageType mtNew = new MessageType();
mtNew.Parent = sb;
mt = (MessageType)obj;
mtNew.Name = mt.Name;
mtNew.MessageTypeValidation = mt.MessageTypeValidation;
if (mt.MessageTypeValidation == MessageTypeValidation.XmlSchemaCollection)
{
mtNew.ValidationXmlSchemaCollection = mt.ValidationXmlSchemaCollection;
}
if (isEdit)
{
mtNew.Alter();
}
else
{
mtNew.Create();
}
break;
case SsbEnum.Contract:
ServiceContract scNew = new ServiceContract();
sc = (ServiceContract)obj;
scNew.Parent = sb;
scNew.Name = sc.Name;
foreach (MessageTypeMapping mtm in sc.MessageTypeMappings)
{
if (!sb.MessageTypes.Contains(mtm.Name))
{
ServiceBroker sbParent = sc.Parent;
MessageType mtp = sbParent.MessageTypes[mtm.Name];
DeploySsbObj(mtp, svrName, dbName, SsbEnum.MessageType, false);
}
MessageTypeMapping mtmNew = new MessageTypeMapping();
mtmNew.Name = mtm.Name;
mtmNew.Parent = scNew;
mtmNew.MessageSource = mtm.MessageSource;
scNew.MessageTypeMappings.Add(mtmNew);
}
if (isEdit)
{
scNew.Alter();
}
else
{
scNew.Create();
}
break;
case SsbEnum.Queu:
q = (ServiceQueue)obj;
q.Parent = sb;
if (isEdit)
{
q.Alter();
}
else
{
q.Create();
}
break;
case SsbEnum.Service:
serv = (BrokerService)obj;
serv.Parent = sb;
if (isEdit)
{
serv.Alter();
}
else
{
serv.Create();
}
break;
case SsbEnum.Route:
rt = (ServiceRoute)obj;
rt.Parent = sb;
if (isEdit)
{
rt.Alter();
}
else
{
rt.Create();
}
break;
case SsbEnum.RemoteBinding:
bind = (RemoteServiceBinding)obj;
bind.Parent = sb;
if (isEdit)
{
bind.Alter();
}
else
{
bind.Create();
}
break;
}
}
catch (FailedOperationException e) {
string err = string.Format("{0}", e.InnerException);
//throw;
}
catch (Exception ex) {
string errx = string.Format("{0}", ex.InnerException);
}
finally {
svr.ConnectionContext.Disconnect();
}
}
internal static void DeleteObject(SsbEnum sType, object smoObj)
{
switch (sType)
{
case SsbEnum.Database:
Database db = null;
if (smoObj.GetType() == typeof(SSBIDatabase))
{
db = ((SSBIDatabase)smoObj).DataBase;
}
else if (smoObj.GetType() == typeof(Database))
{
db = (Database)smoObj;
}
db.Drop();
break;
case SsbEnum.MessageType:
MessageType mt = (MessageType)smoObj;
mt.Drop();
break;
case SsbEnum.Contract:
ServiceContract sc = (ServiceContract)smoObj;
sc.Drop();
break;
case SsbEnum.Queu:
ServiceQueue sq = (ServiceQueue)smoObj;
sq.Drop();
break;
case SsbEnum.Service:
BrokerService bs = (BrokerService)smoObj;
bs.Drop();
break;
case SsbEnum.Route:
ServiceRoute sr = (ServiceRoute)smoObj;
sr.Drop();
break;
case SsbEnum.RemoteBinding:
RemoteServiceBinding rsb = (RemoteServiceBinding)smoObj;
rsb.Drop();
break;
case SsbEnum.Conversation:
SSBIConversation cnv = (SSBIConversation)smoObj;
smo.EndConversation(cnv);
break;
case SsbEnum.EndPoint:
Endpoint ep = (Endpoint)smoObj;
ep.Drop();
break;
case SsbEnum.Certificate:
Certificate cert = (Certificate)smoObj;
cert.Drop();
break;
}
}
protected abstract Task RemveAddressAsync(IEnumerable <AddressModel> address, ServiceRoute route);
public ServiceRouteChangedEventArgs(ServiceRoute route, ServiceRoute oldRoute) : base(route)
{
OldRoute = oldRoute;
}
public ServiceRouteEventArgs(ServiceRoute route)
{
Route = route;
}
public void ServiceRouteEqualsTest()
{
ServiceRoute model1 = null, model2 = null;
Action reset = () =>
{
model1 =
new ServiceRoute
{
Address = new[]
{
new IpAddressModel("127.0.0.1", 1234)
},
ServiceDescriptor = new ServiceDescriptor
{
Id = "service1",
Metadatas = new Dictionary <string, object>
{
{ "key1", 1 }
}
}
};
model2 =
new ServiceRoute
{
Address = new[]
{
new IpAddressModel("127.0.0.1", 1234)
},
ServiceDescriptor = new ServiceDescriptor
{
Id = "service1",
Metadatas = new Dictionary <string, object>
{
{ "key1", 1 }
}
}
};
};
reset();
Assert.Equal(model1, model2);
Assert.True(model1 == model2);
Assert.True(model1.Equals(model2));
model2.ServiceDescriptor.Id = "service2";
Assert.NotEqual(model1, model2);
Assert.False(model1 == model2);
Assert.False(model1.Equals(model2));
model1.ServiceDescriptor.Id = "service2";
Assert.Equal(model1, model2);
Assert.True(model1 == model2);
Assert.True(model1.Equals(model2));
reset();
model2.Address.OfType <IpAddressModel>().First().Port = 1111;
Assert.NotEqual(model1, model2);
Assert.False(model1 == model2);
Assert.False(model1.Equals(model2));
}
protected override async Task RemveAddressAsync(IEnumerable <AddressModel> address, ServiceRoute serviceRoute)
{
serviceRoute.Address = serviceRoute.Address.Except(address).ToList();
await base.SetRouteAsync(serviceRoute);
}
protected override async Task RemveAddressAsync(IEnumerable <AddressModel> address, ServiceRoute route)
{
route.Address = route.Address.Except(address).ToList();
await base.SetRoutesAsync(new List <ServiceRoute>() { route });
}
public static void SetRouteTable()
{
webServiceHostFactory = new TMWebServiceHostFactory();
serviceRoute = new ServiceRoute(urlPath, webServiceHostFactory, typeof(TM_REST));
RouteTable.Routes.Add(serviceRoute);
}
public ServiceRouteEventArgs(ServiceRoute route)
{
Route = route;
}
int UpDateSsb()
{
updatedobj = null;
//if (!isDirty)
//return 0;
if (!ValidateData()) {
Cursor crs = Cursor.Current;
Cursor.Current = Cursors.WaitCursor;
try {
Database db = null;
ServiceBroker sb = null;
if (ssbType != SsbEnum.Database && ssbType != SsbEnum.Login && ssbType != SsbEnum.EndPoint) {
sb = dBase.ServiceBroker;
}
switch (ssbType) {
case SsbEnum.Database:
MasterKey mk = null;
SSBIDatabase sbd = null;
if (isEdit) {
sbd = (SSBIDatabase)objToUpdate;
db = sbd.DataBase;
}
else {
db = new Database();
db.Name = txtName.Text;
db.Parent = dbServ.SMOServer;
}
if (isEdit) {
if(db.MasterKey != null && db_chkMasterKey.Checked == false) {
mk = db.MasterKey;
mk.Drop();
}
else if (db.MasterKey == null && db_chkMasterKey.Checked) {
mk = new MasterKey();
mk.Parent = db;
mk.Create(db_txtMkPwd.Text);
}
db.Alter();
if (sbd.IsTrustworthy != db_chkTrustWorthy.Checked)
sbd.IsTrustworthy = db_chkTrustWorthy.Checked;
}
else {
db.Create();
sbd = new SSBIDatabase(db);
if (db_chkMasterKey.Checked) {
mk = new MasterKey();
mk.Parent = db;
mk.Create(db_txtMkPwd.Text);
}
if (db_chkTrustWorthy.Checked) {
sbd.IsTrustworthy = true;
}
}
if (dBase == null)
dBase = db;
//Server serv = db.Parent;
updatedobj = db;
break;
case SsbEnum.MessageType:
MessageType mt = null;
if (isEdit)
mt = (MessageType)objToUpdate;
else {
mt = new MessageType();
mt.Parent = sb;
mt.Name = txtName.Text;
}
if (cboUser.Text != string.Empty)
mt.Owner = cboUser.Text;
mt.MessageTypeValidation = (MessageTypeValidation)Enum.Parse(typeof(MessageTypeValidation), cboVal.Text);
if (cboValSchema.Enabled)
mt.ValidationXmlSchemaCollection = cboValSchema.Text;
if (isEdit)
mt.Alter();
else
mt.Create();
updatedobj = mt;
break;
case SsbEnum.Contract:
ServiceContract sc = new ServiceContract();
sc.Parent = sb;
sc.Name = txtName.Text;
if (cboUser.Text != string.Empty)
sc.Owner = cboUser.Text;
//get the message types
foreach (DataGridViewRow row in dvMsgTypes.Rows) {
sc.MessageTypeMappings.Add(new MessageTypeMapping(sc, row.Cells[0].Value.ToString(), (MessageSource)Enum.Parse(typeof(MessageSource), row.Cells[1].Value.ToString())));
}
if (isEdit)
sc.Alter();
else
sc.Create();
updatedobj = sc;
break;
case SsbEnum.Queu:
ServiceQueue q = null;
if (isEdit)
q = (ServiceQueue)objToUpdate;
else {
q = new ServiceQueue();
q.Parent = sb;
q.Name = txtName.Text;
}
q.IsEnqueueEnabled = chkStatus.Checked;
if (chkRetention.Checked)
q.IsRetentionEnabled = true;
//if (chkActivation.Checked) {
//if(isEdit)
// q.IsActivationEnabled = chkActivation.Checked;
//
if (chkActivation.Checked) {
q.IsActivationEnabled = chkActivation.Checked;
if (dBase.Name != cboQDb.Text)
q.ProcedureDatabase = cboQDb.Text;
StoredProcedure sp = (StoredProcedure)cboProc.SelectedItem;
q.ProcedureSchema = sp.Schema;
q.ProcedureName = cboProc.Text;
q.MaxReaders = short.Parse(txtReaders.Text);
if (rdOwner.Checked)
q.ActivationExecutionContext = ActivationExecutionContext.Owner;
else if (rdSelf.Checked)
q.ActivationExecutionContext = ActivationExecutionContext.Self;
else if (rdUser.Checked) {
q.ActivationExecutionContext = ActivationExecutionContext.ExecuteAsUser;
q.ExecutionContextPrincipal = txtExecuteAs.Text;
}
}
if (isEdit)
q.Alter();
else
q.Create();
updatedobj = q;
break;
case SsbEnum.Service:
BrokerService bserv = null;
if (isEdit)
bserv = (BrokerService)objToUpdate;
else {
bserv = new BrokerService();
bserv.Parent = sb;
bserv.Name = txtName.Text;
}
if (cboUser.Text != string.Empty)
bserv.Owner = cboUser.Text;
ServiceQueue servq = (ServiceQueue)cboQueue.SelectedItem;
bserv.QueueName = servq.Name;
bserv.QueueSchema = servq.Schema;
if (lbChosenCtr.Items.Count > 0) {
foreach (object o in lbChosenCtr.Items) {
ServiceContract servctr = o as ServiceContract;
ServiceContractMapping scm = new ServiceContractMapping(bserv, servctr.Name);
bserv.ServiceContractMappings.Add(scm);
}
}
if (isEdit)
bserv.Alter();
else
bserv.Create();
updatedobj = bserv;
break;
case SsbEnum.Route:
ServiceRoute srt = null;
if (isEdit)
srt = (ServiceRoute)objToUpdate;
else {
srt = new ServiceRoute();
srt.Name = txtName.Text;
srt.Parent = sb;
}
if (cboUser.Text != string.Empty)
srt.Owner = cboUser.Text;
if (textBroker.Text != string.Empty)
srt.BrokerInstance = textBroker.Text;
if (textRemote.Text != string.Empty)
srt.RemoteService = textRemote.Text;
if (textLifeTime.Text != string.Empty)
srt.ExpirationDate = DateTime.Parse(textLifeTime.Text);
if (rdLocal.Checked)
srt.Address = "LOCAL";
if (rdTransport.Checked)
srt.Address = "TRANSPORT";
if (rdTCP.Checked)
srt.Address = "TCP://" + txtAddress.Text;
if (txtMirror.Text != string.Empty)
srt.MirrorAddress = "TCP://" + txtMirror.Text;
//StringCollection sColl = srt.Script();
//foreach (string s in sColl)
// MessageBox.Show(s);
if (isEdit)
srt.Alter();
else
srt.Create();
updatedobj = srt;
break;
case SsbEnum.RemoteBinding:
RemoteServiceBinding remBind = null;
if (isEdit)
remBind = (RemoteServiceBinding)objToUpdate;
else {
remBind = new RemoteServiceBinding();
remBind.Name = txtName.Text;
remBind.Parent = sb;
}
if (cboUser.Text != string.Empty)
remBind.Owner = cboUser.Text;
remBind.RemoteService = textRemServ.Text;
remBind.CertificateUser = cboRemUser.Text;
remBind.IsAnonymous = chkAnon.Checked;
StringCollection sColl = remBind.Script();
foreach (string s in sColl)
MessageBox.Show(s);
if (isEdit)
remBind.Alter();
else
remBind.Create();
updatedobj = remBind;
break;
case SsbEnum.Conversation:
TimeSpan ts = TimeSpan.Zero;
Guid grpHandle = Guid.Empty;
string convContract = "DEFAULT";
BrokerService bServ = (BrokerService)cnv_cboFrmServ.SelectedItem;
string toService = cnv_txtToSrv.Text;
if (cnv_txtLifetime.Text != string.Empty && cnv_txtLifetime.Text != "0")
ts = TimeSpan.FromSeconds(double.Parse(cnv_txtLifetime.Text));
if (cnv_cboContract.Text != string.Empty)
convContract = cnv_cboContract.Text;
if (cnv_txtRelGrpHndl.Text != string.Empty)
grpHandle = new Guid(cnv_txtRelGrpHndl.Text);
//get a service object
Service smoserv = smo.GetSSBIService(bServ.Parent.Parent, bServ.Name);
if (smoserv.Connection.State == ConnectionState.Closed)
smoserv.Connection.Open();
smoserv.Connection.ChangeDatabase(bServ.Parent.Parent.Name);
updatedobj = smoserv.BeginDialog(toService, convContract, ts, cnv_chkEncryption.Checked, grpHandle);
break;
case SsbEnum.Message:
SSBIConversation msgConv = (SSBIConversation)msg_cboConv.SelectedItem;
string servName = msg_txtFrom.Text;
//we need a service object
Service msgSsbiServ = smo.GetSSBIService(dBase, msgConv.FromService);
if (msgSsbiServ.Connection.State== ConnectionState.Closed)
msgSsbiServ.Connection.Open();
msgSsbiServ.Connection.ChangeDatabase(dBase.Name);
Conversation msgCnv = new Conversation(msgSsbiServ, msgConv.Handle);
string msgType = msg_cboMsgType.SelectedText;
string msgString = msg_rchMsg.Text;
msgType = msg_cboMsgType.Text;
MemoryStream msgBody = new MemoryStream(Encoding.ASCII.GetBytes(msgString));
Microsoft.Samples.SqlServer.Message msg = new Microsoft.Samples.SqlServer.Message(msgType, msgBody);
msgCnv.Send(msg);
break;
case SsbEnum.Login :
string pwd = "";
Login lg = new Login();
lg.Parent = dbServ.SMOServer;
lg.Name = lgn_txtLoginName.Text;
if (lgn_rdSql.Checked) {
pwd = lgn_txtPwd.Text;
lg.PasswordPolicyEnforced = lgn_chkEnforcePolicy.Checked;
lg.LoginType = LoginType.SqlLogin;
lg.Create(pwd);
}
else {
lg.Create();
}
updatedobj = lg;
break;
case SsbEnum.Certificate:
string certOwner = "dbo";
int certSource = cert_cboSource.SelectedIndex;
Certificate cert = new Certificate();
if(!isEdit) {
cert.Name = txtName.Text;
if(cboUser.Text != "")
certOwner = cboUser.Text;
cert.Parent = dBase;
cert.Owner = certOwner;
}
cert.ActiveForServiceBrokerDialog = cert_chkBeginDlg.Checked;
if (certSource == 0) {
if (!isEdit) {
if (cert_chkMasterKey.Checked)
cert.Create(cert_txtCertPath.Text, CertificateSourceType.File, cert_txtPrivPath.Text, cert_txtDecrypt.Text);
else
cert.Create(cert_txtCertPath.Text, CertificateSourceType.File, cert_txtPrivPath.Text, cert_txtDecrypt.Text, cert_txtEncrypt.Text);
}
}
else if (certSource == 1) {
if (!isEdit) {
cert.StartDate = cert_dtValidFrom.Value;
cert.ExpirationDate = cert_dtExpiry.Value;
cert.Subject = cert_txtCertPath.Text;
if (cert_chkMasterKey.Checked) {
cert.Create();
}
else {
cert.Create(cert_txtEncrypt.Text);
}
}
}
else if (certSource == 2) {
if (!isEdit) {
cert.Create(cert_txtCertPath.Text, CertificateSourceType.File);
}
}
if (isEdit)
cert.Alter();
updatedobj = cert;
break;
case SsbEnum.User :
User usr;
if (!isEdit) {
usr = new User();
usr.Name = txtName.Text;
usr.Parent = dBase;
if(usr_chkLogin.Checked)
usr.Login = usr_cboLogin.Text;
}
else
usr = (User)objToUpdate;
if (usr_cboCerts.SelectedIndex != -1)
usr.Certificate = usr_cboCerts.Text;
if (!isEdit)
if (usr_chkLogin.Checked)
usr.Create();
else
smo.CreateUserWithNoLogin(usr);
else
usr.Alter();
updatedobj = usr;
break;
case SsbEnum.EndPoint :
Endpoint ep = null;
if (!isEdit) {
ep = new Endpoint();
ep.Name = txtName.Text;
ep.Parent = dbServ.SMOServer;
ep.ProtocolType = ProtocolType.Tcp;
ep.EndpointType = EndpointType.ServiceBroker;
}
else
ep = ((SSBIEndpoint)objToUpdate).EndPoint;
ep.Protocol.Tcp.ListenerPort = int.Parse(ep_txtPort.Text);
if (ep_txtIp.Text == "ALL")
ep.Protocol.Tcp.ListenerIPAddress = System.Net.IPAddress.Any;
else {
ep.Protocol.Tcp.ListenerIPAddress = System.Net.IPAddress.Parse(ep_txtIp.Text);
}
ep.Payload.ServiceBroker.EndpointAuthenticationOrder = (EndpointAuthenticationOrder)ep_cboAuth.SelectedItem;
if (ep_cboCert.SelectedIndex != -1)
ep.Payload.ServiceBroker.Certificate = ep_cboCert.Text;
ep.Payload.ServiceBroker.EndpointEncryption = (EndpointEncryption)ep_cboEncrypt.SelectedItem;
if (ep_cboAlgorithm.SelectedIndex != -1)
ep.Payload.ServiceBroker.EndpointEncryptionAlgorithm = (EndpointEncryptionAlgorithm)ep_cboAlgorithm.SelectedItem;
ep.Payload.ServiceBroker.IsMessageForwardingEnabled = ep_chkFwd.Checked;
if (ep_txtSize.Text != string.Empty)
ep.Payload.ServiceBroker.MessageForwardingSize = int.Parse(ep_txtSize.Text);
if(!isEdit)
ep.Create();
switch ((EndpointState)ep_cboState.SelectedIndex) {
case EndpointState.Disabled :
ep.Disable();
break;
case EndpointState.Started :
ep.Start();
break;
case EndpointState.Stopped :
if (isEdit)
ep.Stop();
break;
}
if (isEdit)
ep.Alter();
break;
case SsbEnum.CreateListing :
CreateListing(true);
break;
}
if (isEdit)
_state = SsbState.Edited;
else
_state = SsbState.New;
Cursor.Current = crs;
this.DialogResult = DialogResult.OK;
ExitAndClose();
}
catch (FailedOperationException e) {
smo.ShowException(e);
}
catch (Exception ex) {
smo.ShowException(ex);
}
finally {
if(dbServ !=null)
dbServ.SMOServer.ConnectionContext.Disconnect();
}
}
return 0;
}
public RouteBuilderController(ServiceRoute route)
{
m_route = route;
}
private static void AddServiceRoute(Type serviceType, string routePrefix, IHttpHostConfigurationBuilder configuration)
{
var route = new ServiceRoute(routePrefix, new RestbucksServiceHostFactory(configuration), serviceType);
RouteTable.Routes.Add(route);
}
