private void correctionButton_Click(object sender, System.EventArgs e)
        {
            if (false == ValidatePublisher())
            {
                return;
            }

            try
            {
                ConnectionManager.BeginTransaction();

                //
                // Deserialize into a change record object
                //
                StringReader reader = new StringReader(correctionTextBox.Text);

                ChangeRecordCorrection changeRecordCorrection = ( ChangeRecordCorrection )correctionSerializer.Deserialize(reader);

                //
                // Validate what we created.
                //
                SchemaCollection.Validate(changeRecordCorrection);

                //
                // Create a new change record to hold the correction.
                //
                ChangeRecord changeRecord = new ChangeRecord(changeRecordCorrection);
                changeRecord.Process();
                ConnectionManager.Commit();

                //
                // If we made it this far, we were able to process the correction
                //
                MessageBox.Show("Correction processed!");

                //
                // Refresh our display.
                //
                ShowChangeRecord();
            }
            catch (Exception exception)
            {
                ConnectionManager.Abort();

                MessageBox.Show("An exception occurred when trying to process the correction:\r\n\r\n" + exception.ToString());
            }
        }
Example #2
0
        static int Main(string[] args)
        {
            int retCode = 1;             // assume error

            //
            // Check if CurrentUICulture needs to be overridden
            //
            UDDI.Localization.SetConsoleUICulture();

            Console.WriteLine(FormatFromResource("BOOTSTRAP_COPYRIGHT_1"));
            Console.WriteLine(FormatFromResource("BOOTSTRAP_COPYRIGHT_2"));
            Console.WriteLine();

            //
            // parse the command line
            //
            if (!ProcessCommandLine(args))
            {
                return(1);
            }

            WindowsPrincipal prin = new WindowsPrincipal(WindowsIdentity.GetCurrent());

            try
            {
                ConnectionManager.Open(true, true);
            }
            catch
            {
                Console.WriteLine(FormatFromResource("BOOTSTRAP_DB_CONNECT_FAILED"));
                return(1);
            }

            try
            {
                //
                // Setup the UDDI user credentials
                //
                Context.User.SetRole(prin);

                //
                // Verify that the user is a member of the administrators group
                //
                if (!Context.User.IsAdministrator)
                {
                    //
                    // 735728 - Show an error to the user and exit the program.
                    //
                    Console.WriteLine(FormatFromResource("BOOTSTRAP_ACCESS_DENIED"));
                    Console.WriteLine(FormatFromResource("BOOTSTRAP_ADMIN_GROUP_ONLY"));
                    Console.WriteLine(FormatFromResource("BOOTSTRAP_USER_NOT_ADMIN", WindowsIdentity.GetCurrent().Name));

                    return(1);
                }

                if (null != username && 0 != username.Length)
                {
                    //
                    // The /u option was specified
                    //

                    Context.User.SetPublisherRole(username);
                    if (!Context.User.IsRegistered)
                    {
                        //
                        // 735728 - Show an error to the user and exit the program.
                        //
                        Console.WriteLine(FormatFromResource("BOOTSTRAP_USER_NOT_REGISTERED", username));

                        return(1);
                    }

                    //
                    // If the current user is not the same as the publisher, set up impersonation
                    //

                    if (Context.User.ID != WindowsIdentity.GetCurrent().Name)
                    {
                        Context.User.ImpersonatorID = WindowsIdentity.GetCurrent().Name;
                    }
                }
                else
                {
                    //
                    // Default is to save data under the default publisher
                    //
                    Context.User.ID = UDDI.Utility.GetDefaultPublisher();
                }

                //
                // If user is not system publisher, a temporary operator must be added to support pre-assigned key behavior
                //

                string operatorkey = System.Guid.NewGuid().ToString();

                if (Context.User.ID != UDDI.Utility.GetDefaultPublisher())
                {
                    Context.User.SetAllowPreassignedKeys(true);
                }

                XmlSerializer serializer = new XmlSerializer(typeof(UDDI.API.Extensions.Resources));

                //
                // Load the XML file.
                //
                Console.WriteLine(FormatFromResource("BOOTSTRAP_PROCESSING_MSG", filename, Context.User.ID));

                FileStream strm = new FileStream(filename, FileMode.Open, FileAccess.Read);
                Resources.Validate(strm);
                Resources resources = (Resources)serializer.Deserialize(strm);
                strm.Close();

                //
                // Save the TModel
                //
                Console.WriteLine(FormatFromResource("BOOTSTRAP_SAVING"));

                //
                // Determine the number of tModels that we imported.
                //
                int tModelCount = 0;
                if (null != resources.TModelDetail)
                {
                    tModelCount += resources.TModelDetail.TModels.Count;
                }

                if (null != resources.CategorizationSchemes)
                {
                    foreach (CategorizationScheme scheme in resources.CategorizationSchemes)
                    {
                        if (null != scheme.TModel)
                        {
                            tModelCount++;
                        }
                    }
                }
                Console.WriteLine(FormatFromResource("BOOTSTRAP_TMODELS", tModelCount));

                if (null != resources.CategorizationSchemes)
                {
                    Console.WriteLine(FormatFromResource("BOOTSTRAP_CATEGORIZATION_SCHEMES", resources.CategorizationSchemes.Count));
                }
                else
                {
                    Console.WriteLine(FormatFromResource("BOOTSTRAP_CATEGORIZATION_SCHEMES", 0));
                }

                if (null != resources.BusinessDetail)
                {
                    Console.WriteLine(FormatFromResource("BOOTSTRAP_PROVIDERS", resources.BusinessDetail.BusinessEntities.Count));
                }
                else
                {
                    Console.WriteLine(FormatFromResource("BOOTSTRAP_PROVIDERS", 0));
                }

                if (null != resources.ServiceDetail)
                {
                    Console.WriteLine(FormatFromResource("BOOTSTRAP_SERVICES", resources.ServiceDetail.BusinessServices.Count));
                }
                else
                {
                    Console.WriteLine(FormatFromResource("BOOTSTRAP_SERVICES", 0));
                }

                if (null != resources.BindingDetail)
                {
                    Console.WriteLine(FormatFromResource("BOOTSTRAP_BINDINGS", resources.BindingDetail.BindingTemplates.Count));
                }
                else
                {
                    Console.WriteLine(FormatFromResource("BOOTSTRAP_BINDINGS", 0));
                }

                resources.Save();

                Console.WriteLine(FormatFromResource("BOOTSTRAP_COMPLETE"));

                ConnectionManager.Commit();

                retCode = 0;                 // no error
            }
            catch (Exception e)
            {
                Console.WriteLine();
                Console.WriteLine(FormatFromResource("BOOTSTRAP_FAILED", e.Message));

                //
                // 735713 - Output an additional message if the user did not have permissions to modify an entity.
                //
                SqlException sqlException = e as SqlException;
                if (null != sqlException)
                {
                    if (sqlException.Number - UDDI.Constants.ErrorTypeSQLOffset == ( int )ErrorType.E_userMismatch)
                    {
                        Console.WriteLine(FormatFromResource("ERROR_USER_MISMATCH"));
                    }
                }

                ConnectionManager.Abort();
            }
            finally
            {
                ConnectionManager.Close();
            }

            return(retCode);
        }
        public override void ProcessMessage(SoapMessage message)
        {
            Debug.Enter();

#if DEBUG
            string info = "log: " + data.log.ToString() +
                          "; https: " + data.https.ToString() +
                          "; validate: " + data.validate.ToString() +
                          "; performance: " + data.performance.ToString() +
                          "; authenticate: " + data.authenticate.ToString() +
                          "; transaction: " + data.transaction.ToString() +
                          "; messageType: " + data.messageType;

            Debug.Write(SeverityType.Info, CategoryType.Soap, info);
#endif
            try
            {
                switch (message.Stage)
                {
                //
                // First Event
                //
                case SoapMessageStage.BeforeDeserialize:
                    //
                    // Initialize our context.
                    //
                    Context.Current.Initialize();

                    Config.CheckForUpdate();

                    //
                    // TODO: Since we are using DispositionReport.ThrowFinal() I don't think this is
                    // needed anymore.
                    //

                    //
                    // Check to make sure the authenticated user has user credentials
                    //
                    Debug.Verify("1" != HttpContext.Current.Request.ServerVariables["Exception"],
                                 "UDDI_ERROR_FATALERROR_VERSIONCHECKERROR",
                                 UDDI.ErrorType.E_fatalError);

                    Debug.Write(SeverityType.Info, CategoryType.Soap, "URL: " + message.Url);
                    Debug.Write(SeverityType.Info, CategoryType.Soap, "SOAPAction: " + HttpContext.Current.Request.Headers["SOAPAction"]);

                    string contentType = HttpContext.Current.Request.ContentType.ToLower();

                    bool validEncoding = (contentType.IndexOf("charset=\"utf-8\"") >= 0) ||
                                         (contentType.IndexOf("charset=utf-8") >= 0);

                    Debug.Verify(validEncoding, "UDDI_ERROR_UNSUPPORTED_CONTENTTYPEHEADERMISSING", ErrorType.E_unsupported);

                    if (data.performance)
                    {
                        PublishMethodBegin(message);
                    }

                    if (data.https)
                    {
                        CheckForHttps(message);
                    }

                    //
                    // Validation has been moved into the other SOAP extension
                    //
//						if( data.validate )
//							Validate( message );

                    break;

                //
                // Second Event
                //
                case SoapMessageStage.AfterDeserialize:

                    ConnectionManager.Open(data.transaction, data.transaction);

                    if (data.certificate)
                    {
                        CheckCertificate(message);
                    }

                    if (data.authenticate)
                    {
                        Authenticate(message);
                    }
                    else if (0 != (Config.GetInt("Security.AuthenticationMode", (int)AuthenticationMode.Both)
                                   & (int)AuthenticationMode.AuthenticatedRead))
                    {
                        //
                        // Authenticated reads are turned on and this is a read request
                        // Make sure the caller is authenticated using Windows and is at least a user
                        //
                        WindowsIdentity      identity = (WindowsIdentity)HttpContext.Current.User.Identity;
                        WindowsAuthenticator wa       = new WindowsAuthenticator();
                        wa.Authenticate("", 0 /* not used */);

                        Debug.Write(SeverityType.Info, CategoryType.Soap, "Authenticated user: using Windows based authentication Identity is " + identity.Name);

                        //
                        // Check to make sure the authenticated user has user credentials
                        //
                        Debug.Verify(Context.User.IsUser,
                                     "UDDI_ERROR_FATALERROR_NOUSERCREDS",
                                     UDDI.ErrorType.E_fatalError,
                                     Context.User.ID);
                    }

                    break;

                //
                // Third Event
                //
                case SoapMessageStage.BeforeSerialize:
                    break;

                //
                // Last Event
                //
                case SoapMessageStage.AfterSerialize:

                    //
                    // Cleanup the connection and commit the database activity
                    //
                    if (data.transaction &&
                        (null != (object)ConnectionManager.GetConnection()) &&
                        (null != (object)ConnectionManager.GetTransaction()))
                    {
                        if (null == (object)message.Exception)
                        {
                            ConnectionManager.Commit();
                        }
                        else
                        {
                            ConnectionManager.Abort();
                        }
                    }

                    ConnectionManager.Close();

                    try
                    {
                        if (data.performance)
                        {
                            PublishMethodEnd(message);
                        }
                    }
                    catch
                    {
                        Debug.OperatorMessage(
                            SeverityType.Warning,
                            CategoryType.None,
                            OperatorMessageType.UnableToPublishCounter,
                            "An error occurred while trying to publish a performance counter, the system will continue");
                    }

                    break;

                default:
                    throw new UDDIException(ErrorType.E_fatalError, "UDDI_ERROR_FATALERROR_UNKNOWNEXTSTAGE");
                }
            }
            catch (Exception e)
            {
                DispositionReport.Throw(e);
            }

            Debug.Leave();
        }
Example #4
0
        static void FixDefaultURLs()
        {
            //
            // Get a list of business keys that have non-default discovery URLs.
            //
            ArrayList businessEntities = GetBusinessEntities();
            int       total            = businessEntities.Count;
            int       current          = 1;
            int       numberFixed      = 0;

            foreach (BusinessEntity businessEntity in businessEntities)
            {
                //
                // Get values for this business.
                //
                businessEntity.Get();

                //
                // BusinessEntity.Get() may add the default one, we don't want it.
                //
                DiscoveryUrlCollection originalList = new DiscoveryUrlCollection();
                originalList.Get(businessEntity.BusinessKey);
                businessEntity.DiscoveryUrls = originalList;

                Log("*** Processing " + current++ + "/" + total + " *** ");

                LogStartBusinessEntity(businessEntity);

                DiscoveryUrlCollection filteredList = GetFilterList(businessEntity);

                if (filteredList.Count < businessEntity.DiscoveryUrls.Count)
                {
                    try
                    {
                        numberFixed++;

                        LogFixStart(filteredList);

                        ConnectionManager.BeginTransaction();

                        //
                        // Remove duplicate discovery URLs
                        //
                        businessEntity.DiscoveryUrls = filteredList;

                        //
                        // Fix change records
                        //
                        FixChangeRecords(businessEntity);

                        //
                        // Fix data.  Saving the BusinessEntity will also create a ChangeRecordNew data in our replication stream.
                        // Other operators will consume this change record, which will update their databases.
                        //

                        FixData(businessEntity);
#if never
                        ChangeRecordNewData changeRecordNewData = new ChangeRecordNewData(businessEntity);
                        ChangeRecord        fixData             = new ChangeRecord(changeRecordNewData);
                        fixData.Process();
#endif
                        ConnectionManager.Commit();

                        LogFixEnd(businessEntity);
                    }
                    catch (Exception e)
                    {
                        WriteException(e);
                        ConnectionManager.Abort();
                    }
                }
                LogDoneBusinessEntity(businessEntity);
            }
            Log("BusinessEntities fixed: " + numberFixed);
        }