// Provider Registration methods - issued by the provider
public static string RegisterClientServices(int sbId, Coupon lssCoupon, int lssId,
Coupon lsCoupon, int lsId, Coupon clientCoupon, int clientId)
{
bool error = false;
StringBuilder message = new StringBuilder();
string lsDescriptor = null;
string lssDescriptor = null;
string clientDescriptor = null;
ProcessAgentInfo remoteSB;
ProcessAgentDB db = new ProcessAgentDB();
ResourceDescriptorFactory factory = ResourceDescriptorFactory.Instance();
try
{
// Check for enough information to perform the register
lsDescriptor = factory.CreateProcessAgentDescriptor(lsId);
if(lssId > 0)
lssDescriptor = factory.CreateProcessAgentDescriptor(lssId);
clientDescriptor = factory.CreateClientDescriptor(clientId);
// What tickets do we need, create them
string guid = Utilities.MakeGuid();
ServiceDescription[] values = null;
if (lssDescriptor != null)
{
// Order is important
values = new ServiceDescription[3];
values[0] = new ServiceDescription(lssDescriptor, lssCoupon, null);
values[1] = new ServiceDescription(lsDescriptor, lsCoupon, null);
values[2] = new ServiceDescription(clientDescriptor, clientCoupon, null);
}
else
{
values = new ServiceDescription[2];
values[0] = new ServiceDescription(lsDescriptor, lsCoupon, null);
values[1] = new ServiceDescription(clientDescriptor, clientCoupon, null);
}
// get the remote sb Proxy
remoteSB = db.GetProcessAgentInfo(sbId);
if (remoteSB == null || remoteSB.retired)
{
throw new Exception("The remote service broker is not registered or is retired");
}
ProcessAgentProxy sbProxy = new ProcessAgentProxy();
sbProxy.Url = remoteSB.webServiceUrl;
sbProxy.AgentAuthHeaderValue = new AgentAuthHeader();
sbProxy.AgentAuthHeaderValue.coupon = remoteSB.identOut;
sbProxy.AgentAuthHeaderValue.agentGuid = ProcessAgentDB.ServiceGuid;
sbProxy.Register(guid, values);
message.AppendLine("RegisterClientServices: " + remoteSB.webServiceUrl + " \t" + guid + " \t" + "success");
}
catch (Exception ex)
{
Utilities.WriteLog("Error in cross-Register: " + ex.Message);
message.AppendLine("Error in cross-Register: " + ex.Message);
//throw;
}
return message.ToString();
}
protected override void register(string registerGuid, ServiceDescription[] info)
{
StringBuilder message = new StringBuilder();
message.AppendLine("Service " + ProcessAgentDB.ServiceAgent.codeBaseUrl + " recieved a 'Register' webService call.");
if (info == null)
{
//message.AppendLine("Register called without any ServiceDescriptions");
throw new ArgumentNullException("Register called without any ServiceDescriptions");
}
try
{
base.register(registerGuid, info);
}
catch (Exception e)
{
message.AppendLine("Error in base.register" + Utilities.DumpException(e));
throw new Exception(message.ToString(), e);
}
bool hasProvider = false;
bool hasConsumer = false;
string ns = "";
int lssID = 0;
int lsID = 0;
ProcessAgentInfo ls = null;
ProcessAgentInfo lss = null;
ProcessAgentInfo uss = null;
LabClient labClient = null;
GroupCredential credential = null;
try
{
ResourceDescriptorFactory rFactory = ResourceDescriptorFactory.Instance();
string jobGuid = registerGuid;
message.AppendLine(" Register called at " + DateTime.UtcNow + " UTC \t registerGUID: " + registerGuid);
ProcessAgent sourceAgent = brokerDB.GetProcessAgent(agentAuthHeader.agentGuid);
message.AppendLine("Source Agent: " + sourceAgent.agentName);
for (int i = 0; i < info.Length; i++)
{
Coupon coupon = null;
if (info[i].coupon != null)
{
coupon = info[i].coupon;
}
if (info[i].serviceProviderInfo != null && info[i].serviceProviderInfo.Length > 0)
{
// ProviderInfo is simple add to database and create qualifier
if (!hasProvider)
{
message.AppendLine("Provider Info:");
hasProvider = true;
}
XmlQueryDoc xdoc = new XmlQueryDoc(info[i].serviceProviderInfo);
string descriptorType = xdoc.GetTopName();
if (descriptorType.Equals("processAgentDescriptor"))
{
string paGuid = xdoc.Query("/processAgentDescriptor/agentGuid");
string paType = xdoc.Query("/processAgentDescriptor/type");
if (paType.Equals(ProcessAgentType.LAB_SCHEDULING_SERVER))
{
lssID = brokerDB.GetProcessAgentID(paGuid);
if (lssID > 0)
{
// Already in database
//message.AppendLine("Reference to existing LSS: " + lssID + " GUID: " + paGuid);
}
else
{
lss = rFactory.LoadProcessAgent(xdoc, ref message);
lssID = lss.agentId;
}
}
else if (paType.Equals(ProcessAgentType.LAB_SERVER))
{
lsID = brokerDB.GetProcessAgentID(paGuid);
if (lsID > 0)
{
// Already in database
//message.AppendLine("Reference to existing LS: " + lsID + " GUID: " + paGuid);
}
else
{
ls = rFactory.LoadProcessAgent(xdoc, ref message);
lsID = ls.agentId;
}
int myLssID = brokerDB.FindProcessAgentIdForAgent(lsID, ProcessAgentType.LAB_SCHEDULING_SERVER);
if ((lssID > 0) && (myLssID <= 0) && (lssID != myLssID))
{
brokerDB.AssociateLSS(lsID, lssID);
}
}
}
else if (descriptorType.Equals("clientDescriptor"))
{
int clientId = -1;
string clientGuid = xdoc.Query("/clientDescriptor/clientGuid");
clientId = AdministrativeAPI.GetLabClientID(clientGuid);
if (clientId > 0)
{
// Already in database
message.Append(" Attempt to Register a LabClient that is already in the database. ");
message.AppendLine(" GUID: " + clientGuid);
}
else
{
// LabServer should already be in the Database, once multiple LS supported may need work
// LS is specified in clientDescriptor
int clientID = rFactory.LoadLabClient(xdoc, ref message);
message.AppendLine("Adding LabClient: GUID " + clientGuid);
}
}
else if (descriptorType.Equals("systemSupport"))
{
// Already handled in base.register
}
// Add Relationships: LSS, LS Client
} // end of ServiceProvider
if (info[i].consumerInfo != null && info[i].consumerInfo.Length > 0)
{
// requestSystemSupport Handled by base register & there is no xml dcument
if (info[i].consumerInfo.CompareTo("requestSystemSupport") != 0)
{
message.AppendLine("Consumer Info: " + info[i].consumerInfo);
//if (!hasConsumer)
// message.AppendLine("Consumer Info: " + info[i].consumerInfo);
hasConsumer = true;
XmlQueryDoc xdoc = new XmlQueryDoc(info[i].consumerInfo);
string descriptorType = xdoc.GetTopName();
if (descriptorType.Equals("processAgentDescriptor"))
{
string paGuid = xdoc.Query("/processAgentDescriptor/agentGuid");
ProcessAgentInfo paInfo = brokerDB.GetProcessAgentInfo(paGuid);
if (paInfo == null)
{
// Not in database
paInfo = rFactory.LoadProcessAgent(xdoc, ref message);
message.Append("Loaded new ");
}
else
{
message.Append("Reference to existing ");
if (paInfo.retired)
{
throw new Exception("The ProcessAgent is retired");
}
}
if (paInfo.agentType == ProcessAgentType.AgentType.LAB_SCHEDULING_SERVER)
{
lss = paInfo;
message.AppendLine("LSS: " + paGuid);
}
else if (paInfo.agentType == ProcessAgentType.AgentType.LAB_SERVER)
{
ls = paInfo;
message.AppendLine("LS: " + paGuid);
}
else if (paInfo.agentType == ProcessAgentType.AgentType.SCHEDULING_SERVER)
{
uss = paInfo;
message.AppendLine("USS: " + paGuid);
if (lss != null)
{
if (lss.domainGuid.Equals(ProcessAgentDB.ServiceGuid))
{
message.AppendLine("Registering USSinfo on LSS: " + lss.agentName);
LabSchedulingProxy lssProxy = new LabSchedulingProxy();
lssProxy.AgentAuthHeaderValue = new AgentAuthHeader();
lssProxy.AgentAuthHeaderValue.coupon = lss.identOut;
lssProxy.AgentAuthHeaderValue.agentGuid = ProcessAgentDB.ServiceGuid;
lssProxy.Url = lss.webServiceUrl;
lssProxy.AddUSSInfo(uss.agentGuid, uss.agentName, uss.webServiceUrl, coupon);
}
else
{
message.AppendLine("LSS is not from this domain");
}
}
}
}
else if (descriptorType.Equals("clientDescriptor"))
{
int newClientId = -1;
string clientGuid = xdoc.Query("/clientDescriptor/clientGuid");
int clientId = AdministrativeAPI.GetLabClientID(clientGuid);
if (clientId > 0)
{
// Already in database
message.Append(" Attempt to Register a LabClient that is already in the database. ");
message.AppendLine(" GUID: " + clientGuid);
}
else
{
clientId = rFactory.LoadLabClient(xdoc, ref message);
message.AppendLine("Adding Lab Client GUID: " + clientGuid);
}
}
else if (descriptorType.Equals("credentialDescriptor"))
{
credential = rFactory.ParseCredential(xdoc, ref message);
if (lss != null)
{
if (lss.domainGuid.Equals(ProcessAgentDB.ServiceGuid))
{
message.AppendLine("Registering Group Credentials on LSS: " + lss.agentName);
message.AppendLine("Group: " + credential.groupName + " DomainServer: " + credential.domainServerName);
LabSchedulingProxy lssProxy = new LabSchedulingProxy();
lssProxy.AgentAuthHeaderValue = new AgentAuthHeader();
lssProxy.AgentAuthHeaderValue.coupon = lss.identOut;
lssProxy.AgentAuthHeaderValue.agentGuid = ProcessAgentDB.ServiceGuid;
lssProxy.Url = lss.webServiceUrl;
lssProxy.AddCredentialSet(credential.domainGuid, credential.domainServerName, credential.groupName, credential.ussGuid);
}
else
{
message.AppendLine("LSS is not from this domain");
}
}
}
}
}
} // End of info loop
} // End of Try
catch (Exception ex)
{
message.Append("Exception in Register: " + Utilities.DumpException(ex));
throw new Exception(message.ToString(),ex);
}
finally
{
// Send a mail Message
StringBuilder sb = new StringBuilder();
MailMessage mail = new MailMessage();
mail.To = ConfigurationManager.AppSettings["supportMailAddress"];
//mail.To = "*****@*****.**";
mail.From = ConfigurationManager.AppSettings["genericFromMailAddress"];
mail.Subject = "Register called on " + ProcessAgentDB.ServiceAgent.agentName;
mail.Body = message.ToString();
SmtpMail.SmtpServer = "127.0.0.1";
try
{
SmtpMail.Send(mail);
}
catch (Exception ex)
{
// Report detailed SMTP Errors
StringBuilder smtpErrorMsg = new StringBuilder();
smtpErrorMsg.Append("Exception: " + ex.Message);
//check the InnerException
if (ex.InnerException != null)
smtpErrorMsg.Append("<br>Inner Exceptions:");
while (ex.InnerException != null)
{
smtpErrorMsg.Append("<br>" + ex.InnerException.Message);
ex = ex.InnerException;
}
Logger.WriteLine(smtpErrorMsg.ToString());
}
}
}
// Error recovery must be added to this method
protected void btnSaveChange_Click(object sender, EventArgs e)
{
int id = int.Parse(ddlLabClient.SelectedValue);
if (id > 0)
{
LabClient[] clients = wrapper.GetLabClientsWrapper(new int[] { id });
if (clients.Length > 0 && clients[0].clientID > 0)
{
theClient = clients[0];
}
}
// objects used in try block may be required for recovery if errors
bool noError = true;
ProcessAgentInfo labServer = null;
ProcessAgentInfo uss = null;
ProcessAgentInfo lss = null;
long rmUss = 0;
lblResponse.Visible = false;
lblResponse.Text = "";
try
{
if (ddlUserGroup.SelectedIndex <= 0)
{
lblResponse.Visible = true;
lblResponse.Text = Utilities.FormatWarningMessage("Please select a user group from the corresponding drop-down list.");
return;
}
int groupID = Convert.ToInt32(ddlUserGroup.SelectedValue);
if (groupID <= 0)
{
lblResponse.Visible = true;
lblResponse.Text = Utilities.FormatWarningMessage("The user group is invalid.");
return;
}
//Get the user Group Name to be displayed in the repeater
Group[] userGroup = wrapper.GetGroupsWrapper(new int[] { groupID });
string userGroupName = userGroup[0].GroupName;
if (theClient.labServerIDs != null && theClient.labServerIDs.Length > 0)
{
labServer = issuer.GetProcessAgentInfo(theClient.labServerIDs[0]);
}
if (labServer == null)
{
lblResponse.Visible = true;
lblResponse.Text = Utilities.FormatWarningMessage("Lab Client should first be associated with a Lab Server");
return;
}
if (theClient.needsScheduling)
{
if (ddlAdminGroup.SelectedIndex <= 0 || ddlUserGroup.SelectedIndex <= 0)
{
lblResponse.Visible = true;
lblResponse.Text = Utilities.FormatWarningMessage("Please select a user and management group from the corresponding drop-down lists.");
return;
}
int manageID = Convert.ToInt32(ddlAdminGroup.SelectedValue);
if (manageID <= 0)
{
lblResponse.Visible = true;
lblResponse.Text = Utilities.FormatWarningMessage("The management group is invalid.");
return;
}
int ussId = issuer.FindProcessAgentIdForClient(theClient.clientID, ProcessAgentType.SCHEDULING_SERVER);
if (ussId <= 0)
{
lblResponse.Visible = true;
lblResponse.Text = Utilities.FormatWarningMessage("Lab Client should first be associated with a USS");
return;
}
int lssId = issuer.FindProcessAgentIdForAgent(theClient.labServerIDs[0], ProcessAgentType.LAB_SCHEDULING_SERVER);
if (lssId <= 0)
{
lblResponse.Visible = true;
lblResponse.Text = Utilities.FormatWarningMessage("Lab Server should first be associated with an LSS");
return;
}
else
{
uss = issuer.GetProcessAgentInfo(ussId);
if (uss.retired)
{
throw new Exception("The USS is retired");
}
lss = issuer.GetProcessAgentInfo(lssId);
if (lss.retired)
{
throw new Exception("The LSS is retired");
}
//Object keyObj = groupID;
//string keyType = ResourceMappingTypes.GROUP;
ResourceMappingKey key = new ResourceMappingKey(ResourceMappingTypes.GROUP, groupID);
ResourceMappingValue[] values = new ResourceMappingValue[3];
values[0] = new ResourceMappingValue(ResourceMappingTypes.CLIENT, theClient.clientID);
values[1] = new ResourceMappingValue(ResourceMappingTypes.TICKET_TYPE,
TicketTypes.GetTicketType(TicketTypes.MANAGE_USS_GROUP));
values[2] = new ResourceMappingValue(ResourceMappingTypes.GROUP,manageID);
//values[0] = new ResourceMappingValue(ResourceMappingTypes.RESOURCE_TYPE, ProcessAgentType.SCHEDULING_SERVER);
//values[1] = new ResourceMappingValue(ResourceMappingTypes.PROCESS_AGENT, ussId);
ResourceMapping newMapping = issuer.AddResourceMapping(key, values);
rmUss = newMapping.MappingID;
// add mapping to qualifier list
int qualifierType = Qualifier.resourceMappingQualifierTypeID;
string name = issuer.ResourceMappingToString(newMapping);
int qualifierID = AuthorizationAPI.AddQualifier(newMapping.MappingID, qualifierType, name, Qualifier.ROOT);
//Give the Manager Group a Grant "MANAGE_USS_GROUP" on the created resource mapping
string function = Function.manageUSSGroup;
int grantID = wrapper.AddGrantWrapper(manageID, function, qualifierID);
//Get the management Group Name to be displayed in the repeater
Group[] adminGroup = wrapper.GetGroupsWrapper(new int[] { manageID });
string adminGroupName = adminGroup[0].GroupName;
//Create the Map between user and management group
GroupManagerUserMap groupMap = new GroupManagerUserMap(adminGroupName, userGroupName, grantID, newMapping.MappingID);
TicketLoadFactory factory = TicketLoadFactory.Instance();
//long duration = 60;
// Get this SB's domain Guid
string domainGuid = ProcessAgentDB.ServiceGuid;
string sbName = ProcessAgentDB.ServiceAgent.agentName;
//Add Credential set on the USS
//string ussPayload = factory.createAdministerUSSPayload(Convert.ToInt32(Session["userTZ"]));
//Coupon ussCoupon = issuer.CreateTicket(TicketTypes.ADMINISTER_USS, uss.agentGuid,
// issuer.GetIssuerGuid(), duration, ussPayload);
UserSchedulingProxy ussProxy = new UserSchedulingProxy();
ussProxy.Url = uss.webServiceUrl;
ussProxy.AgentAuthHeaderValue = new AgentAuthHeader();
ussProxy.AgentAuthHeaderValue.coupon = uss.identOut;
ussProxy.AgentAuthHeaderValue.agentGuid = domainGuid;
ussProxy.AddCredentialSet(domainGuid, sbName, userGroupName);
// Check for existing RevokeReservation ticket redeemer = USS, sponsor = LSS
Coupon[] revokeCoupons = issuer.RetrieveIssuedTicketCoupon(
TicketTypes.REVOKE_RESERVATION, uss.agentGuid, lss.agentGuid);
Coupon revokeCoupon = null;
if (revokeCoupons != null && revokeCoupons.Length > 0)
{
revokeCoupon = revokeCoupons[0];
}
else
{
// Create RevokeReservation ticket
revokeCoupon = issuer.CreateTicket(TicketTypes.REVOKE_RESERVATION,
uss.agentGuid, lss.agentGuid, -1L, factory.createRevokeReservationPayload());
}
//Add Credential set on the LSS
// check if this domain
if (ProcessAgentDB.ServiceGuid.Equals(lss.domainGuid))
{
LabSchedulingProxy lssProxy = new LabSchedulingProxy();
lssProxy.Url = lss.webServiceUrl;
lssProxy.AgentAuthHeaderValue = new AgentAuthHeader();
lssProxy.AgentAuthHeaderValue.coupon = lss.identOut;
lssProxy.AgentAuthHeaderValue.agentGuid = domainGuid;
// Add the USS to the LSS, this may be called multiple times with duplicate data
lssProxy.AddUSSInfo(uss.AgentGuid, uss.agentName, uss.webServiceUrl, revokeCoupon);
int credentialSetAdded = lssProxy.AddCredentialSet(domainGuid,
sbName, userGroupName, uss.agentGuid);
}
else
{ // Cross-Domain Registration needed
ProcessAgentInfo remoteSB = issuer.GetProcessAgentInfo(lss.domainGuid);
if(remoteSB.retired){
throw new Exception("The remote service broker is retired");
}
ResourceDescriptorFactory resourceFactory = ResourceDescriptorFactory.Instance();
string ussDescriptor = resourceFactory.CreateProcessAgentDescriptor(ussId);
string lssDescriptor = resourceFactory.CreateProcessAgentDescriptor(lssId);
string groupDescriptor = resourceFactory.CreateGroupCredentialDescriptor(domainGuid, sbName, userGroupName, uss.agentGuid, lss.agentGuid);
ServiceDescription[] info = new ServiceDescription[3];
info[0] = new ServiceDescription(null, revokeCoupon, ussDescriptor);
info[1] = new ServiceDescription(null, null, lssDescriptor);
info[2] = new ServiceDescription(null, null, groupDescriptor);
ProcessAgentProxy sbProxy = new ProcessAgentProxy();
sbProxy.AgentAuthHeaderValue = new AgentAuthHeader();
sbProxy.AgentAuthHeaderValue.agentGuid = domainGuid;
sbProxy.AgentAuthHeaderValue.coupon = remoteSB.identOut;
sbProxy.Url = remoteSB.webServiceUrl;
sbProxy.Register(Utilities.MakeGuid(), info);
}
}
}
/*Update Lab Client grants*/
//Get qualifier for labclient
int lcQualifierID = AuthorizationAPI.GetQualifierID(theClient.clientID, Qualifier.labClientQualifierTypeID);
//Get all "uselabclient" grants for this labclient
int[] lcGrantIDs = wrapper.FindGrantsWrapper(-1, Function.useLabClientFunctionType, lcQualifierID);
Grant[] lcGrants = wrapper.GetGrantsWrapper(lcGrantIDs);
//Get list of agents that can use labclient
ArrayList lcAgents = new ArrayList();
foreach (Grant g in lcGrants)
lcAgents.Add(g.agentID);
//if that agent doesn't already have the uselabclient permission
if (!lcAgents.Contains(groupID))
//add lab client grant
wrapper.AddGrantWrapper(groupID, Function.useLabClientFunctionType, lcQualifierID);
/*Update Lab Servers grant*/
//Update grants for each of the associated lab servers
foreach (int lsID in theClient.labServerIDs)
{
//Get qualifier for labserver
int lsQualifierID = AuthorizationAPI.GetQualifierID(lsID, Qualifier.labServerQualifierTypeID);
//Get all "uselabserver" grants for this labserver
int[] lsGrantIDs = wrapper.FindGrantsWrapper(-1, Function.useLabServerFunctionType, lsQualifierID);
Grant[] lsGrants = wrapper.GetGrantsWrapper(lsGrantIDs);
//Get list of agents that can use labserver
ArrayList lsAgents = new ArrayList();
foreach (Grant g in lsGrants)
lsAgents.Add(g.agentID);
//int groupID = Convert.ToInt32(ddlUserGroup.SelectedValue);
//if that agent doesn't already have the uselabclient permission
if (!lsAgents.Contains(groupID))
//add lab server grant
wrapper.AddGrantWrapper(groupID, Function.useLabServerFunctionType, lsQualifierID);
}
//Refresh the repeater
RefreshAdminUserGroupsRepeater();
LoadListBoxes();
lblResponse.Visible = true;
lblResponse.Text = Utilities.FormatConfirmationMessage("Lab client (& corresponding lab servers) successfully updated. ");
}
catch (Exception ex)
{
lblResponse.Visible = true;
lblResponse.Text = Utilities.FormatErrorMessage("Cannot update Lab Client. " + ex.GetBaseException());
}
}
/// <summary>
/// Generate New Incoming Passkey Button
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
protected void btnRegister_Click(object sender, System.EventArgs e)
{
int agentID = 0;
ProcessAgent service = ProcessAgentDB.ServiceAgent;
if (service == null)
{
lblErrorMessage.Visible = true;
lblErrorMessage.Text = Utilities.FormatErrorMessage("This service broker has not been configured. You must perform selfRegistration before any other services are registered.");
return;
}
if (txtServiceType.Text.Equals(ProcessAgentType.BATCH_LAB_SERVER))
{
bool hasError = false;
StringBuilder errorMess = new StringBuilder();
errorMess.AppendLine("Error: Registering a Batch LabServer you are missing the following fields:");
if (txtWebServiceURL.Text == null || txtWebServiceURL.Text.Length == 0)
{
hasError = true;
errorMess.Append('\t' + "Web Service URL");
}
if (txtServiceGUID.Text == null || txtServiceGUID.Text.Length == 0 || txtServiceGUID.Text.Length > 35)
{
hasError = true;
errorMess.Append('\t' + "Service GUID: Batch LabServer Guids must be between 1 and 35 characters");
}
//if (txtBatchPassIn.Text == null || txtBatchPassIn.Text.Length == 0)
//{
// hasError = true;
// errorMess.Append('\t' + "Passcode From LabServer");
//}
//if (txtBatchPassOut.Text == null || txtBatchPassOut.Text.Length == 0)
//{
// hasError = true;
// errorMess.Append('\t' + "Passcode To LabServer");
//}
if (txtApplicationURL.Text == null || txtApplicationURL.Text.Length == 0)
{
hasError = true;
errorMess.Append('\t' + "Codebase URL");
}
if (txtServiceName.Text == null || txtServiceName.Text.Length == 0)
{
hasError = true;
errorMess.Append('\t' + "Service Name");
}
if (hasError)
{
errorMess.AppendLine("");
lblErrorMessage.Visible = true;
lblErrorMessage.Text = Utilities.FormatErrorMessage(errorMess.ToString());
return;
}
// Missing fields check passed start to create the BatchLabServer records,
// hopefully the data is correct,
// Since InstallDomainCredentials is not supported by the 6.1 Batch labs we must
// only do one side of the operation.
// Batch labs have a one to one relationship with service brokers,
// this means it must be a member of this domain
int tstID = brokerDB.GetProcessAgentID(txtServiceGUID.Text);
if (tstID > 0)
{
lblErrorMessage.Visible = true;
lblErrorMessage.Text = Utilities.FormatErrorMessage("A service with the specified Guid has already been registered.");
return;
}
Coupon inCoupon = null;
if (txtBatchPassIn.Text != null && txtBatchPassIn.Text.Length > 0)
{
inCoupon = brokerDB.CreateCoupon(txtBatchPassIn.Text);
}
Coupon outCoupon = null;
if (txtBatchPassOut.Text != null && txtBatchPassOut.Text.Length > 0)
{
outCoupon = brokerDB.CreateCoupon(txtBatchPassOut.Text);
}
agentID = wrapper.AddProcessAgentWrapper(txtServiceGUID.Text, txtServiceName.Text,
ProcessAgentType.BATCH_LAB_SERVER, ProcessAgentDB.ServiceGuid, txtApplicationURL.Text,
txtWebServiceURL.Text, inCoupon, outCoupon);
modifySystemSupport(agentID);
if (agentID > 0)
{
lblErrorMessage.Visible = true;
lblErrorMessage.Text = Utilities.FormatConfirmationMessage("Relationship with the service has been created and saved.");
}
ClearButtonScripts();
}
else
{ // Interactive service
if ((txtWebServiceURL.Text == "") || (txtOutPassKey.Text == ""))
{
lblErrorMessage.Visible = true;
lblErrorMessage.Text = Utilities.FormatErrorMessage("Please specify a Web Service URL and initial passkey before registering the service.");
return;
}
else
{
try
{
Coupon inIdentCoupon = brokerDB.CreateCoupon();
Coupon outIdentCoupon = brokerDB.CreateCoupon();
ProcessAgent agent = null;
ProcessAgentProxy proxy = new ProcessAgentProxy();
InitAuthHeader data = new InitAuthHeader();
proxy.Url = txtWebServiceURL.Text.Trim();
data.initPasskey = txtOutPassKey.Text.Trim();
proxy.InitAuthHeaderValue = data;
agent = proxy.InstallDomainCredentials(service, inIdentCoupon, outIdentCoupon);
if (agent != null)
{
if (agent.type.Equals(ProcessAgentType.SERVICE_BROKER))
agent.type = ProcessAgentType.REMOTE_SERVICE_BROKER;
agentID = wrapper.AddProcessAgentWrapper(agent.agentGuid, agent.agentName, agent.type,
agent.domainGuid, agent.codeBaseUrl, agent.webServiceUrl,
outIdentCoupon, inIdentCoupon);
// Create the default AdminUrls
switch (agent.type)
{
case ProcessAgentType.EXPERIMENT_STORAGE_SERVER:
//brokerDB.InsertAdminURL(agentId, agent.codeBaseUrl + "/administer.aspx", TicketTypes.ADMINISTER_ESS);
break;
case ProcessAgentType.LAB_SCHEDULING_SERVER:
brokerDB.InsertAdminURL(agentID, agent.codeBaseUrl + "/administer.aspx", TicketTypes.ADMINISTER_LSS);
brokerDB.InsertAdminURL(agentID, agent.codeBaseUrl + "/manage.aspx", TicketTypes.MANAGE_LAB);
break;
case ProcessAgentType.LAB_SERVER:
brokerDB.InsertAdminURL(agentID, agent.codeBaseUrl + "/administer.aspx", TicketTypes.ADMINISTER_LS);
brokerDB.InsertAdminURL(agentID, agent.codeBaseUrl + "/administer.aspx", TicketTypes.MANAGE_LAB);
break;
case ProcessAgentType.SCHEDULING_SERVER:
brokerDB.InsertAdminURL(agentID, agent.codeBaseUrl + "/administer.aspx", TicketTypes.ADMINISTER_USS);
brokerDB.InsertAdminURL(agentID, agent.codeBaseUrl + "/manage.aspx", TicketTypes.MANAGE_USS_GROUP);
brokerDB.InsertAdminURL(agentID, agent.codeBaseUrl + "/Reservation.aspx", TicketTypes.SCHEDULE_SESSION);
break;
case ProcessAgentType.REMOTE_SERVICE_BROKER:
default:
break;
}
SystemSupport mySS = brokerDB.RetrieveSystemSupport(ProcessAgentDB.ServiceGuid);
if (mySS != null)
{
ServiceDescription[] values = new ServiceDescription[1];
values[0] = new ServiceDescription(mySS.ToXML(), null, "requestSystemSupport");
proxy.AgentAuthHeaderValue = new AgentAuthHeader();
proxy.AgentAuthHeaderValue.coupon = inIdentCoupon;
proxy.AgentAuthHeaderValue.agentGuid = ProcessAgentDB.ServiceGuid;
proxy.Register(Utilities.MakeGuid(), values);
}
lblErrorMessage.Visible = true;
lblErrorMessage.Text = Utilities.FormatConfirmationMessage("Relationship with the service has been created and saved.");
// set the script of the "Admin URL button"
SetBtnScripts(agent.agentGuid,agent.type);
}
}
catch (Exception ex)
{
lblErrorMessage.Visible = true;
//lblErrorMessage.Text = Utilities.FormatErrorMessage("InstallDomainCredentials Error: " + Utilities.DumpException(ex));
lblErrorMessage.Text = Utilities.FormatErrorMessage("InstallDomainCredentials Error: " + ex.Message);
}
}
}
InitializeDropDown();
if (agentID > 0)
{
ddlService.Items.FindByValue(agentID.ToString()).Selected = true;
//SetInputMode(true);
displayService(agentID);
}
else
{
if (ddlService.Items.Count > 0)
{
ddlService.Items[0].Selected = true;
}
}
}
protected virtual void register(string registerGuid, ServiceDescription[] info)
{
StringBuilder message = new StringBuilder("Register called on " + ProcessAgentDB.ServiceAgent.codeBaseUrl);
if (info != null && info.Length > 0)
{
foreach (ServiceDescription sd in info)
{
Coupon coupon = null;
if (sd.coupon != null)
{
coupon = sd.coupon;
}
XmlQueryDoc xdoc = new XmlQueryDoc(sd.serviceProviderInfo);
string descriptorType = xdoc.GetTopName();
if (descriptorType.Equals("systemSupport"))
{
SystemSupport ss = SystemSupport.Parse(xdoc);
if (ss.agentGuid != null && ss.agentGuid.Length > 0)
{
int id = dbTicketing.GetProcessAgentID(ss.agentGuid);
if (id > 0)
{
dbTicketing.SaveSystemSupport(ss.agentGuid, ss.contactEmail, ss.bugEmail,
ss.infoUrl, ss.description, ss.location);
if (sd.consumerInfo != null && sd.consumerInfo.CompareTo("requestSystemSupport") == 0)
{
ProcessAgentInfo paInfo = dbTicketing.GetProcessAgentInfo(ss.agentGuid);
if (paInfo != null)
{
SystemSupport mySS = dbTicketing.RetrieveSystemSupport(ProcessAgentDB.ServiceGuid);
if (mySS != null)
{
ServiceDescription[] values = new ServiceDescription[1];
values[0] = new ServiceDescription(mySS.ToXML(), null, null);
ProcessAgentProxy proxy = new ProcessAgentProxy();
proxy.Url = paInfo.webServiceUrl;
proxy.AgentAuthHeaderValue = new AgentAuthHeader();
proxy.AgentAuthHeaderValue.coupon = paInfo.identOut;
proxy.AgentAuthHeaderValue.agentGuid = ProcessAgentDB.ServiceGuid;
proxy.Register(registerGuid, values);
}
}
}
}
}
}
}
}
}
public void Register(string registerGuid, ServiceDescription[] info)
{
if (dbTicketing.AuthenticateAgentHeader(agentAuthHeader))
{
// This is an optional method, the base method is a no-op.
register(registerGuid, info);
}
}