Ejemplo n.º 1
0
        protected void btnRegisterUSS_Click(object sender, EventArgs e)
        {
            lblResponse.Visible = false;
            lblResponse.Text = "";

            StringBuilder message = new StringBuilder();
            try
            {
                if (ddlLabClient.SelectedIndex == 0)
                {
                    lblResponse.Visible = true;
                    lblResponse.Text = Utilities.FormatErrorMessage("Please save the Lab Client information before attempting to dissociate it from a resource");
                    return;
                }

                if (ddlAssociatedUSS.SelectedIndex == 0)
                {
                    lblResponse.Visible = true;
                    lblResponse.Text = Utilities.FormatErrorMessage("Please select a desired USS to be associated with the client.");
                    return;
                }

                LabClient lc = new LabClient();
                lc = labClients[ddlLabClient.SelectedIndex - 1];

                Object keyObj = int.Parse(ddlLabClient.SelectedValue);
                string keyType = ResourceMappingTypes.CLIENT;

                ArrayList valuesList = new ArrayList();
                Object valueObj = null;

                ResourceMappingValue value = new ResourceMappingValue(ResourceMappingTypes.RESOURCE_TYPE, ProcessAgentType.SCHEDULING_SERVER);
                valuesList.Add(value);

                int ussId = int.Parse(ddlAssociatedUSS.SelectedValue);

                if (ussId > 0)
                {
                    value = new ResourceMappingValue(ResourceMappingTypes.PROCESS_AGENT, ussId);
                    valuesList.Add(value);

                    value = new ResourceMappingValue(ResourceMappingTypes.TICKET_TYPE,
                        TicketTypes.GetTicketType(TicketTypes.SCHEDULE_SESSION));
                    valuesList.Add(value);

                    ResourceMappingKey key = new ResourceMappingKey(keyType, keyObj);
                    ResourceMappingValue[] values = (ResourceMappingValue[])valuesList.ToArray((new ResourceMappingValue()).GetType());

                    // Add the mapping to the database & cache
                    ResourceMapping newMapping = ticketing.AddResourceMapping(key, values);

                    // add mapping to qualifier list
                    int qualifierType = Qualifier.resourceMappingQualifierTypeID;
                    string name = ticketing.ResourceMappingToString(newMapping);
                    int qualifierID = AuthorizationAPI.AddQualifier(newMapping.MappingID, qualifierType, name, Qualifier.ROOT);

                    // Moved to ManageLabGroups
                    //Give the Manager Group a Grant "MANAGE_USS_GROUP" on the created resource mapping
                    //int agentID = Convert.ToInt32(ddlAdminGroup.SelectedValue);
                    //string function = Function.manageUSSGroup;
                    //int grantID = wrapper.AddGrantWrapper(agentID, function, qualifierID);

                    Session["ClientUssMappingID"] = newMapping.MappingID;

                    btnRegisterUSS.Visible = false;
                    btnDissociateUSS.Visible = true;
                    ddlAssociatedUSS.Enabled = false;

                    message.AppendLine("User-side Scheduling Server \"" + ddlAssociatedUSS.SelectedItem.Text + "\" succesfully "
                        + "associated with client \"" + ddlLabClient.SelectedItem.Text + "\".");

                    //wrapper.ModifyLabClientWrapper(lc.clientID, lc.clientName, lc.version, lc.clientShortDescription,
                    //    lc.clientLongDescription, lc.notes, lc.loaderScript, lc.clientType,
                    //    lc.labServerIDs, lc.contactEmail, lc.contactFirstName, lc.contactLastName,
                    //    lc.needsScheduling, lc.needsESS, lc.IsReentrant, lc.clientInfos);

                    TicketLoadFactory factory = TicketLoadFactory.Instance();
                    ProcessAgentInfo uss = ticketing.GetProcessAgentInfo(ussId);
                    if (uss.retired)
                    {
                        throw new Exception("The specified USS is retired");
                    }
                    //this should be in a loop
                    for(int i = 0;i<lc.labServerIDs.Length;i++){

                        if (lc.labServerIDs[i] > 0)
                        {
                            ProcessAgentInfo labServer = ticketing.GetProcessAgentInfo(lc.labServerIDs[i]);
                            if (labServer.retired)
                            {
                                throw new Exception("The lab server is retired");
                            }
                            int lssId = ticketing.FindProcessAgentIdForAgent(lc.labServerIDs[i], ProcessAgentType.LAB_SCHEDULING_SERVER);

                            if (lssId > 0)
                            {

                                ProcessAgentInfo lss = ticketing.GetProcessAgentInfo(lssId);
                                if (lss.retired)
                                {
                                    throw new Exception("The LSS is retired");
                                }
                                // The REVOKE_RESERVATION ticket
                                string revokePayload = factory.createRevokeReservationPayload();
                                Coupon ussCoupon = ticketing.CreateTicket(TicketTypes.REVOKE_RESERVATION, uss.agentGuid,
                                    lss.agentGuid, -1L, revokePayload);

                                // Is this in the domain or cross-domain
                                if (lss.domainGuid.Equals(ProcessAgentDB.ServiceGuid))
                                {
                                    // this domain
                                    //Add USS on LSS

                                    //string lssPayload = factory.createAdministerLSSPayload(Convert.ToInt32(Session["UserTZ"]));
                                    //long duration = 60; //seconds for the LSS to redeem the ticket of this coupon and Add LSS Info
                                    //ticketing.AddTicket(lssCoupon, TicketTypes.ADMINISTER_LSS, lss.agentGuid,
                                    //    ticketing.ServiceGuid(), duration, lssPayload);

                                    LabSchedulingProxy lssProxy = new LabSchedulingProxy();
                                    lssProxy.Url = lss.webServiceUrl;
                                    lssProxy.AgentAuthHeaderValue = new AgentAuthHeader();
                                    lssProxy.AgentAuthHeaderValue.coupon = lss.identOut;
                                    lssProxy.AgentAuthHeaderValue.agentGuid = ProcessAgentDB.ServiceGuid;
                                    int ussAdded = lssProxy.AddUSSInfo(uss.agentGuid, uss.agentName, uss.webServiceUrl, ussCoupon);
                                    lssProxy.AddExperimentInfo(labServer.agentGuid, labServer.agentName, lc.clientGuid, lc.clientName, lc.version, lc.contactEmail);
                                }
                                else
                                {
                                    // cross-domain
                                    // send consumerInfo to remote SB
                                    int remoteSbId = ticketing.GetProcessAgentID(lss.domainGuid);
                                    message.AppendLine(RegistrationSupport.RegisterClientUSS(remoteSbId, null, lss.agentId, null, labServer.agentId,
                                        ussCoupon, uss.agentId, null, lc.clientID));

                                }
                                //ADD LSS on USS
                                string ussPayload = factory.createAdministerUSSPayload(Convert.ToInt32(Session["UserTZ"]));

                                UserSchedulingProxy ussProxy = new UserSchedulingProxy();
                                ussProxy.Url = uss.webServiceUrl;
                                ussProxy.AgentAuthHeaderValue = new AgentAuthHeader();
                                ussProxy.AgentAuthHeaderValue.coupon = uss.identOut;
                                ussProxy.AgentAuthHeaderValue.agentGuid = ProcessAgentDB.ServiceGuid;
                                int lssAdded = ussProxy.AddLSSInfo(lss.agentGuid, lss.agentName, lss.webServiceUrl);

                                //Add Experiment Information on USS
                                int expInfoAdded = ussProxy.AddExperimentInfo(labServer.agentGuid, labServer.agentName,
                                    lc.clientGuid, lc.clientName, lc.version, lc.contactEmail, lss.agentGuid);

                                // Group Credentials MOVED TO THE MANAGE LAB GROUPS PAGE
                            }
                        }
                    }
                }
            }
            catch
            {
                throw;
            }
            lblResponse.Visible = true;
            lblResponse.Text = Utilities.FormatConfirmationMessage(message.ToString());
        }
        protected int registerUSS(int ussID, ref StringBuilder message)
        {
            int status = 1;
            ProcessAgentInfo uss = null;
            try
            {
                if (labClientID <= 0)
                {
                    message.AppendLine("Please save the Lab Client information before attempting to associate it with a resource.");
                    status = 0;
                }

                if (ddlAssociatedUSS.SelectedIndex == 0)
                {
                    message.AppendLine("Please select a desired USS to be associated with the client.");
                    status = 0;
                }
                if (status < 1)
                    return status;

                if (ussID > 0)
                {
                    uss = ticketing.GetProcessAgentInfo(ussID);
                    if (uss != null)
                    {
                        if (uss.retired)
                        {
                            message.AppendLine("The specified USS is retired.<br/>");
                            return 0;
                        }

                        TicketLoadFactory factory = TicketLoadFactory.Instance();

                        //this should be in a loop
                        int[] labServerIDs = AdministrativeAPI.GetLabServerIDsForClient(labClientID);
                        if (labServerIDs != null && labServerIDs.Length > 0)
                        {
                            for (int i = 0; i < labServerIDs.Length; i++)
                            {

                                if (labServerIDs[i] > 0)
                                {
                                    ProcessAgentInfo labServer = ticketing.GetProcessAgentInfo(labServerIDs[i]);
                                    if (labServer.retired)
                                    {
                                        message.AppendLine("The lab server: " + labServer.agentName + " is retired!<br/>");
                                    }
                                    int lssId = ticketing.FindProcessAgentIdForAgent(labServerIDs[i], ProcessAgentType.LAB_SCHEDULING_SERVER);

                                    if (lssId > 0)
                                    {

                                        ProcessAgentInfo lss = ticketing.GetProcessAgentInfo(lssId);
                                        if (lss != null)
                                        {
                                            if (lss.retired)
                                            {
                                                message.AppendLine("The LSS: " + lss.agentName + " is retired!<br/>");
                                                return 0;
                                            }
                                            LabSchedulingProxy lssProxy = new LabSchedulingProxy();
                                            lssProxy.Url = lss.webServiceUrl;
                                            lssProxy.AgentAuthHeaderValue = new AgentAuthHeader();
                                            lssProxy.AgentAuthHeaderValue.coupon = lss.identOut;
                                            lssProxy.AgentAuthHeaderValue.agentGuid = ProcessAgentDB.ServiceGuid;

                                            // Is this in the domain or cross-domain
                                            //if (lss.domainGuid.Equals(ProcessAgentDB.ServiceGuid))
                                           // {
                                                lssProxy.AddExperimentInfo(labServer.agentGuid, labServer.agentName, labClient.clientGuid, labClient.clientName, labClient.version, labClient.contactEmail);
                                            //}

                                            // check for existing REVOKE_RESERVATION tickets
                                            bool needUssRevoke = true;
                                            bool needLssRevoke = true;
                                            Coupon ussRevokeCoupon = null;
                                            Coupon lssRevokeCoupon = null;
                                            Ticket ussRevoke = null;
                                            Ticket lssRevoke = null;
                                            Ticket[] ussRevokeTickets = ticketing.RetrieveIssuedTickets(-1L,
                                                    TicketTypes.REVOKE_RESERVATION, uss.agentGuid, lss.agentGuid);
                                            if (ussRevokeTickets != null && ussRevokeTickets.Length > 0)
                                            {
                                                ussRevoke = ussRevokeTickets[0];
                                                needUssRevoke = false;
                                            }

                                            Ticket[] lssRevokeTickets = ticketing.RetrieveIssuedTickets(-1L,
                                                    TicketTypes.REVOKE_RESERVATION, lss.agentGuid, uss.agentGuid);
                                            if (lssRevokeTickets != null && lssRevokeTickets.Length > 0)
                                            {
                                                lssRevoke = lssRevokeTickets[0];
                                                needLssRevoke = false;
                                            }

                                            if (ussRevoke == null && lssRevoke == null)
                                            {
                                                ussRevokeCoupon = ticketing.CreateCoupon();
                                                lssRevokeCoupon = ussRevokeCoupon;
                                            }
                                            if (needUssRevoke)
                                            {
                                                string ussRevokePayload = factory.createRevokeReservationPayload("LSS");
                                                if (ussRevokeCoupon == null)
                                                {
                                                    ussRevokeCoupon = ticketing.CreateTicket(TicketTypes.REVOKE_RESERVATION,
                                                        uss.agentGuid, lss.agentGuid, -1L, ussRevokePayload);
                                                }
                                                else
                                                {
                                                    ticketing.AddTicket(ussRevokeCoupon, TicketTypes.REVOKE_RESERVATION,
                                                        uss.agentGuid, lss.agentGuid, -1L, ussRevokePayload);
                                                }

                                                // Is this in the domain or cross-domain
                                                if (lss.domainGuid.Equals(ProcessAgentDB.ServiceGuid))
                                                { // this domain
                                                    //Add USS on LSS
                                                    int ussAdded = lssProxy.AddUSSInfo(uss.agentGuid, uss.agentName, uss.webServiceUrl, ussRevokeCoupon);
                                                    status = 1;
                                                }
                                                else
                                                {
                                                    // cross-domain
                                                    // send consumerInfo to remote SB
                                                    int remoteSbId = ticketing.GetProcessAgentID(lss.domainGuid);
                                                    message.AppendLine(RegistrationSupport.RegisterClientUSS(remoteSbId, null, lss.agentId, null, labServer.agentId,
                                                        ussRevokeCoupon, uss.agentId, null, labClient.clientID));
                                                }
                                            }
                                            UserSchedulingProxy ussProxy = new UserSchedulingProxy();
                                            ussProxy.Url = uss.webServiceUrl;
                                            ussProxy.AgentAuthHeaderValue = new AgentAuthHeader();
                                            ussProxy.AgentAuthHeaderValue.coupon = uss.identOut;
                                            ussProxy.AgentAuthHeaderValue.agentGuid = ProcessAgentDB.ServiceGuid;
                                            if (needLssRevoke)
                                            {
                                                //ADD LSS on USS
                                                string ussPayload = factory.createAdministerUSSPayload(Convert.ToInt32(Session["UserTZ"]));
                                                string lssRevokePayload = factory.createRevokeReservationPayload("USS");
                                                if (lssRevokeCoupon == null)
                                                {
                                                    lssRevokeCoupon = ticketing.CreateTicket(TicketTypes.REVOKE_RESERVATION, lss.agentGuid, uss.agentGuid, -1L, lssRevokePayload);
                                                }
                                                else
                                                {
                                                    ticketing.AddTicket(lssRevokeCoupon, TicketTypes.REVOKE_RESERVATION, lss.agentGuid, uss.agentGuid, -1L, lssRevokePayload);
                                                }

                                                int lssAdded = ussProxy.AddLSSInfo(lss.agentGuid, lss.agentName, lss.webServiceUrl, lssRevokeCoupon);
                                            }
                                            //Add Experiment Information on USS
                                            int expInfoAdded = ussProxy.AddExperimentInfo(labServer.agentGuid, labServer.agentName,
                                                labClient.clientGuid, labClient.clientName, labClient.version, labClient.contactEmail, lss.agentGuid);

                                            //Ceate resource Map
                                            ResourceMappingKey key = new ResourceMappingKey(ResourceMappingTypes.CLIENT, labClientID);
                                            List<ResourceMappingValue> valuesList = new List<ResourceMappingValue>();
                                            valuesList.Add(new ResourceMappingValue(ResourceMappingTypes.RESOURCE_TYPE, ProcessAgentType.SCHEDULING_SERVER));
                                            valuesList.Add(new ResourceMappingValue(ResourceMappingTypes.PROCESS_AGENT, ussID));
                                            valuesList.Add(new ResourceMappingValue(ResourceMappingTypes.TICKET_TYPE,
                                                TicketTypes.GetTicketType(TicketTypes.SCHEDULE_SESSION)));
                                            // Add the mapping to the database & cache
                                            ResourceMapping newMapping = ticketing.AddResourceMapping(key, valuesList.ToArray());

                                            // add mapping to qualifier list
                                            int qualifierType = Qualifier.resourceMappingQualifierTypeID;
                                            string name = ticketing.ResourceMappingToString(newMapping);
                                            int qualifierID = AuthorizationAPI.AddQualifier(newMapping.MappingID, qualifierType, name, Qualifier.ROOT);

                                            // Group Credentials MOVED TO THE MANAGE LAB GROUPS PAGE
                                        }
                                        else
                                        {
                                            message.AppendLine("The specified LSS was not found!<br/>");
                                            return 0;
                                        }
                                    }
                                    else
                                    {
                                        message.AppendLine("You must assign a LSS to the lab server before you may assign a USS!<br/>");
                                        return 0;
                                    }
                                }
                            }
                        }
                        else
                        {
                            message.AppendLine("You must assign a Lab Server before assigning a USS!<br/>");
                            return 0;
                        }
                        btnRegisterUSS.Visible = true;
                        btnRegisterUSS.Text = "Dissociate";
                        ddlAssociatedUSS.Visible = false;
                        txtAssociatedUSS.Visible = true;
                        txtAssociatedUSS.Text = ddlAssociatedUSS.SelectedItem.Text;
                        hdnUssID.Value = ussID.ToString();

                        message.AppendLine("User-side Scheduling Server \"" + ddlAssociatedUSS.SelectedItem.Text + "\" succesfully "
                            + "associated with client \"" + ddlLabClient.SelectedItem.Text + "\".");
                    }
                }
                else
                {
                    message.AppendLine("USS was not found!<br/>");
                    return 0;
                }
            }
            catch (Exception e)
            {
                message.AppendLine("Exception: " + e.Message);
                return -1;
            }
            return status;
        }
        // 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;
                int[] labServerIDs = AdministrativeAPI.GetLabServerIDsForClient(theClient.clientID);
                if (labServerIDs != null && labServerIDs.Length > 0)
                {
                    labServer = issuer.GetProcessAgentInfo(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(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;

                        // Check for existing RevokeReservation tickets
                        Coupon[] ussRevokeCoupons = issuer.RetrieveIssuedTicketCoupon(
                            TicketTypes.REVOKE_RESERVATION, lss.agentGuid, uss.agentGuid);
                        Coupon[] lssRevokeCoupons = issuer.RetrieveIssuedTicketCoupon(
                            TicketTypes.REVOKE_RESERVATION, uss.agentGuid, lss.agentGuid);
                        Coupon ussRevokeCoupon = null;
                        Coupon lssRevokeCoupon = null;
                        Coupon revokeCoupon = null;
                        if (ussRevokeCoupons != null && ussRevokeCoupons.Length > 0)
                        {
                            ussRevokeCoupon = ussRevokeCoupons[0];
                        }
                        if (lssRevokeCoupons != null && lssRevokeCoupons.Length > 0)
                        {
                            lssRevokeCoupon = lssRevokeCoupons[0];
                        }
                        if (ussRevokeCoupon == null && lssRevokeCoupon == null)
                        {
                            revokeCoupon = issuer.CreateCoupon();
                            // Create RevokeReservation ticket
                            issuer.AddTicket(revokeCoupon, TicketTypes.REVOKE_RESERVATION,
                                 uss.agentGuid, lss.agentGuid, -1L, factory.createRevokeReservationPayload("LSS"));
                            ussRevokeCoupon = revokeCoupon;
                            issuer.AddTicket(revokeCoupon, TicketTypes.REVOKE_RESERVATION,
                                 lss.agentGuid, uss.agentGuid, -1L, factory.createRevokeReservationPayload("USS"));
                            lssRevokeCoupon = revokeCoupon;
                        }
                        else if (ussRevokeCoupon == null)
                        {
                            ussRevokeCoupon = issuer.CreateCoupon();
                            // Create RevokeReservation ticket
                            issuer.AddTicket(ussRevokeCoupon, TicketTypes.REVOKE_RESERVATION,
                                 uss.agentGuid, lss.agentGuid, -1L, factory.createRevokeReservationPayload("LSS"));
                        }
                        else if (lssRevokeCoupon == null)
                        {
                            lssRevokeCoupon = issuer.CreateCoupon();
                            // Create RevokeReservation ticket
                            issuer.AddTicket(lssRevokeCoupon, TicketTypes.REVOKE_RESERVATION,
                                 lss.agentGuid, uss.agentGuid, -1L, factory.createRevokeReservationPayload("USS"));
                        }

                        //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);
                        ussProxy.AddLSSInfo(lss.AgentGuid, lss.agentName, lss.webServiceUrl, lssRevokeCoupon);

                        //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, ussRevokeCoupon);
                            int credentialSetAdded = lssProxy.AddCredentialSet(domainGuid,
                                sbName, userGroupName, uss.agentGuid);
                            // not sure this is the correct way to handle reserving a block for Lab Maintainance
                            int credSetAdded = lssProxy.AddCredentialSet(domainGuid,
                                sbName, adminGroupName, 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, lssRevokeCoupon, ussDescriptor);
                            info[1] = new ServiceDescription(null, ussRevokeCoupon, 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 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());
            }
        }