/// <summary>
 /// Deletes a single experiment, checks for ESS, deletes from the ESS if needed, deletes Qualifier and the experiment administrative info.
 /// This does not check for authorization the experiment ID should be authorized for deletion before this is called.
 /// </summary>
 /// <param name="experimentID"></param>
 /// <returns></returns>
 public static bool DeleteExperiment(long experimentID)
 {
     bool deleted = false;
      ExperimentSummary summary = InternalDataDB.SelectExperimentSummary(experimentID);
      if (summary.HasEss)
      {
          ProcessAgentDB ticketing = new ProcessAgentDB();
          // Retrieve the ESS Status info and update as needed
          //This uses a generic ReadRecords ticket created for the ESS
          ProcessAgentInfo ess = ticketing.GetProcessAgentInfo(summary.essGuid);
          if ((ess != null) && !ess.retired)
          {
              ExperimentStorageProxy essProxy = new ExperimentStorageProxy();
              essProxy.Url = ess.webServiceUrl;
              essProxy.AgentAuthHeaderValue = new AgentAuthHeader();
              essProxy.AgentAuthHeaderValue.coupon = ess.identOut;
              essProxy.AgentAuthHeaderValue.agentGuid = ProcessAgentDB.ServiceGuid;
              essProxy.DeleteExperiment(experimentID);
          }
      }
     int qualID = Authorization.AuthorizationAPI.GetQualifierID((int)experimentID, Qualifier.experimentQualifierTypeID);
     if (qualID > 0)
         Authorization.AuthorizationAPI.RemoveQualifiers(new int[] { qualID });
     deleted = InternalDataDB.DeleteExperiment(experimentID);
     return deleted;
 }
예제 #2
0
    /// <summary>
    /// Method that does the actual make reservation for the user. 
    /// makes the basis of the parameters from the message and the application database
    /// </summary>
    /// <param name="userName"> the user who is scheduling for the lab; must be registered with the service broker</param>
    /// <param name="groupName">the group name authorized to do a lab</param>
    /// <param name="labServerGuid">lab server which holds the lab that does the actual scheduling</param>
    /// <param name="clientGuid">Guid of the lab being registered for</param>
    /// <param name="start">Start time of a particular period scheduled for</param>
    /// <param name="end">End time of a particular period being scheduled for</param>
    /// <returns>returns a message string that the application bases on for to give the feedback to the user</returns>
    public static string MakeReservation(string userName, string groupName, string labServerGuid,
        string clientGuid, DateTime start, DateTime end)
    {
        string lsGuid = null;
            int status = -1;
            string message = null;
            if (ProcessAgentDB.ServiceAgent != null && ProcessAgentDB.ServiceAgent.domainGuid != null)
            {
                ProcessAgentDB paDb = new ProcessAgentDB();
                ProcessAgentInfo domainServer = paDb.GetProcessAgentInfo(ProcessAgentDB.ServiceAgent.domainGuid);

                InteractiveSBProxy isbProxy = new InteractiveSBProxy();
                isbProxy.AgentAuthHeaderValue = new AgentAuthHeader();
                isbProxy.AgentAuthHeaderValue.agentGuid = ProcessAgentDB.ServiceGuid;
                isbProxy.AgentAuthHeaderValue.coupon = domainServer.identOut;
                isbProxy.Url = domainServer.ServiceUrl;

                string[] types = new string[] { TicketTypes.SCHEDULE_SESSION };

                Coupon opCoupon = isbProxy.RequestAuthorization(types, 600, 			userName, groupName,  labServerGuid, clientGuid);
                if (opCoupon != null)
                {
                    TicketIssuerProxy ticketProxy = new TicketIssuerProxy();
                    ticketProxy.AgentAuthHeaderValue = new AgentAuthHeader();
                    ticketProxy.AgentAuthHeaderValue.agentGuid = ProcessAgentDB.ServiceGuid;
                    ticketProxy.AgentAuthHeaderValue.coupon = domainServer.identOut;
                    ticketProxy.Url = domainServer.ServiceUrl;
                    //the method call below is one which does not returns a null value
                    //in otherwards the ticket value is not created.
                    Ticket ticketSMS = ticketProxy.RedeemTicket(opCoupon, TicketTypes.SCHEDULE_SESSION, ProcessAgentDB.ServiceGuid);
                    if (ticketSMS != null)
                    {
                        if (ticketSMS.payload != null || ticketSMS.payload.Length > 0)
                        {
                            XmlQueryDoc xdoc = new XmlQueryDoc(ticketSMS.payload);
                            string ussURL = xdoc.Query("ScheduleSessionPayload/ussURL");
                            UserSchedulingProxy ussProxy = new UserSchedulingProxy();
                            ussProxy.OperationAuthHeaderValue = new OperationAuthHeader();
                            ussProxy.OperationAuthHeaderValue.coupon = opCoupon;
                            ussProxy.Url = ussURL;

                            TimePeriod[] times = ussProxy.RetrieveAvailableTimePeriods(ProcessAgentDB.ServiceAgent.domainGuid, groupName, labServerGuid,
                                clientGuid, start, end);
                            // Logic to check for final time
                            DateTime resStart = start;
                            DateTime resEnd = end;

                            message = ussProxy.AddReservation(ProcessAgentDB.ServiceAgent.domainGuid, userName, groupName, labServerGuid, clientGuid, resStart, resEnd);
                        }
                    }
                }
                else
                {
                    message = "coupon is null";
                }
            }
            else
            {
                message = "This service is not part of a domain, please contact the administrator!";

            }
            return message;
    }
예제 #3
0
        // 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();
        }
예제 #4
0
        public static string RegisterGroupCredentials(int sbId)
        {
            StringBuilder message = new StringBuilder();
            ProcessAgentInfo remoteSB = null;

            ProcessAgentDB db = new ProcessAgentDB();
            ResourceDescriptorFactory factory = ResourceDescriptorFactory.Instance();
            string guid = Utilities.MakeGuid();
            ServiceDescription[] values = 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("RegisterGroupCredentials: " + remoteSB.webServiceUrl + " \t" + guid + " \t" + "success");
            return message.ToString();
        }
예제 #5
0
        public static ProcessAgentInfo[] GetLabServersForClient(int clientID)
        {
            List<ProcessAgentInfo> servers = null;
            DbConnection myConnection = FactoryDB.GetConnection();
            DbCommand myCommand = FactoryDB.CreateCommand("LabServerClient_RetrieveServerIDs", myConnection);
            myCommand.CommandType = CommandType.StoredProcedure;
            myCommand.Parameters.Add(FactoryDB.CreateParameter( "@labClientID", clientID, DbType.Int32));
            DbDataReader reader = null;
            try
            {
                myConnection.Open();
                reader = myCommand.ExecuteReader();
                if (reader != null && reader.HasRows)
                {
                    servers = new List<ProcessAgentInfo>();
                    ProcessAgentDB paDB = new ProcessAgentDB();
                    while (reader.Read())
                    {

                        int serverID = reader.GetInt32(0);
                        ProcessAgentInfo pai = paDB.GetProcessAgentInfo(serverID);
                        if (pai != null && !pai.retired)
                        {
                            servers.Add(pai);
                        }
                    }
                }
            }
            catch(Exception ex)
            {
                throw new Exception("Exception thrown in getLabServersForClient: " + ex.Message, ex);
            }
            finally
            {
                myConnection.Close();
            }

            if (servers != null)
                return servers.ToArray();
            else
                return null;
        }
 public static ExperimentSummary RetrieveExperimentSummary(long experimentID)
 {
     ExperimentSummary summary = InternalDataDB.SelectExperimentSummary(experimentID);
     if (summary.HasEss && ((summary.status | StorageStatus.CLOSED) == 0))
     {
         ProcessAgentDB ticketing = new ProcessAgentDB();
         // Retrieve the ESS Status info and update as needed
         //This uses a generic ReadRecords ticket created for the ESS
         ProcessAgentInfo ess = ticketing.GetProcessAgentInfo(summary.essGuid);
         if ((ess != null) && !ess.retired)
         {
             ExperimentStorageProxy essProxy = new ExperimentStorageProxy();
             essProxy.Url = ess.webServiceUrl;
             essProxy.OperationAuthHeaderValue = new OperationAuthHeader();
             essProxy.OperationAuthHeaderValue.coupon = ess.identOut;
             StorageStatus status = essProxy.GetExperimentStatus(experimentID);
             bool needsUpdate = false;
             if (status != null)
             {
                 if (summary.closeTime != status.closeTime)
                 {
                     summary.closeTime = status.closeTime;
                     needsUpdate = true;
                 }
                 if (summary.recordCount != status.recordCount)
                 {
                     summary.recordCount = status.recordCount;
                     needsUpdate = true;
                 }
                 if (summary.status != status.status)
                 {
                     summary.status = status.status;
                     needsUpdate = true;
                 }
             }
             if (needsUpdate)
             {
                 InternalDataDB.UpdateExperimentStatus(status);
             }
         }
     }
     return summary;
 }
예제 #7
0
        /// <summary>
        /// This only registers the ProviderInfo systemSupport block(s)
        /// </summary>
        /// <param name="registerGuid"></param>
        /// <param name="info"></param>
        protected virtual void register(string registerGuid, ServiceDescription[] info)
        {
            StringBuilder message = new StringBuilder();
            ProcessAgentDB dbTicketing = new ProcessAgentDB();
            message.AppendLine("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;
                    }
                    if (sd.serviceProviderInfo != null && sd.serviceProviderInfo.Length > 0)
                    {
                        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);
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }