⟦c98fff11c⟧

TextFile

AUTHORIZATION_CHECK => (
declare
    subtype Bogus is Natural range 0 .. 1;
    package Pp is new Parameter_Parser (Bogus);
    Iter : Pp.Iterator := Pp.Parse ("Cmvc, Cmvc.Source_Control");
    Token_Iter : Pp.Iterator := Pp.Parse ("");
    Error : Natural := 0;

    function Product_Name (Iter : Pp.Iterator) return String is
    begin
        if String_Utilities.Equal (Pp.Name (Iter), "NAME") then
            return Pp.Get_Image (Iter);
        else
            return Pp.Name (Iter);
        end if;
    end Product_Name;

begin
    while not Pp.Done (Iter) loop
        declare
            Name : constant String := Product_Name (Iter);
        begin  
            if "!Implementation".Product_Authorization.Is_Registered
                  (Name) then
                Log.Put_Line (Name & " is authorized", Profile.Positive_Msg);
            else
                Log.Put_Line ("Need to Authorize " & Name,
                              Profile.Error_Msg);
                Error := Error + 1;
            end if;
        end;
        Pp.Next (Iter);
    end loop;
    if Error /= 0 then
        Log.Put_Line
           ("Do not proceed until all these products have been authorized",
            Profile.Error_Msg);
        Do_Step ("PROMPT=AUTHORIZE_PRODUCT");
    end if;
end;
)

USERS_CHECK => (
    declare
        Iter : System_Utilities.Session_Iterator;
        Total : Natural := 0;
        use System_Utilities;
    begin
        Operator.Limit_Login (Sessions => 1);
        Log.Put_Line ("Limited logins to 1 user", Profile.Positive_Msg);
        Init (Iter);
        while not Done (Iter) loop
            if Value (Iter) /= Get_Session then
                Log.Put_Line
                   ("User " & User_Name (Value (Iter)) &
                    " is still logged in, and must log off before proceeding",
                    Profile.Warning_Msg);
            end if;
            Next (Iter);
        end loop;
    end;
)

PREPARE_MACHINE => (
declare

    function Standard_Configuration
                (Config : String := System_Utilities.System_Boot_Configuration)
                return Boolean is
        type Std_Configs is (D_12_1_1, D_12_2_4, D_12_5_0);
    begin
        for C in Std_Configs loop
            if String_Utilities.Equal (Config, Std_Configs'Image (C)) then
                return True;
            end if;
        end loop;
        return False;
    end Standard_Configuration;

    function Found_Illegal_Versions return Boolean is
        Below_The_Line : Boolean := False;
        Illegal_Version : Boolean := False;
        Mail_1_Running : Boolean := False;
    begin
        Log.Put_Line
           ("Checking executing configuration version: " &
            System_Utilities.System_Boot_Configuration);
        Io.Set_Output ("!machine.temporary.EEDB_Configuration");
        Io.Put_Line ("vd " & System_Utilities.System_Boot_Configuration);
        Io.Put_Line ("quit");
        Io.Reset_Output;
        Io.Set_Input ("!Machine.Temporary.EEDB_Configuration");
        Io.Set_Output ("!Machine.Temporary.EEDB_Configuration_Output");
        Operator.Internal_System_Diagnosis;
        Io.Reset_Output;
        Io.Reset_Input;
        Io.Set_Input ("!Machine.Temporary.EEDB_Configuration_Output");
        while not Io.End_Of_File loop
            declare
                S : constant String := Io.Get_Line;
            begin
                if String_Utilities.Locate ("------------------------", S) /=
                   0 then
                    Below_The_Line := True;
                end if;
                if Below_The_Line and then
                   String_Utilities.Locate (".XXX", S) /= 0 then
                    Io.Put_Line (S);
                    Illegal_Version := True;
                else
                    if String_Utilities.Locate ("Mail.10", S) /= 0 then
                        Mail_1_Running := "!Implementation".Product_Authorization.Is_Registered ("mail");
                    end if;
                end if;
            end;
        end loop;
        Io.Reset_Input;
        if Mail_1_Running then
            Log.Put_Line
               ("Mail I is authorized; do NOT proceed until this has been unauthorized",
                Profile.Error_Msg);
        end if;
        if Illegal_Version then
            Log.Put_Line
               ("An illegal version(s) for 'below the line' subsystem was found",
                Profile.Warning_Msg);
            if not Standard_Configuration then 
                Log.Put_Line ("It is HIGHLY recommended that this problem is corrected before continuing",
                              Profile.Error_Msg);
                Log.Put_Line ("Please read section on PREREQUISITES TO INSTALLATION",
                              Profile.Error_Msg);
            else
                Log.Put_Line ("Please inform Rational SMSE of this problem",
                                Profile.Warning_Msg);
                Log.Put_Line
                    ("Proceed with the next step if no other errors are present; " &
                     "Do NOT attempt to reclaim EEDB space as this will crash the machine",
                        Profile.Warning_Msg);
            end if;
            return True;
        else
            Log.Put_Line ("Version check OK");
            return False;
        end if;
    end Found_Illegal_Versions;
begin
    if not Found_Illegal_Versions then
        Io.Set_Output ("!machine.temporary.EEDB_Commands");
        Io.Put_Line ("display +");
        Io.Put_Line ("del +");
        Io.Put_Line ("reclaim");
        Io.Put_Line ("snap" & Ascii.Lf & Ascii.Etx);
        Io.Put_Line ("display +");
        Io.Put_Line ("quit");
        Io.Reset_Output;
        Io.Set_Output
           ("!Machine.Release.Archive.Environment.D_12_6_5.Logs.EEDB_GC_Log");
        Io.Set_Input ("!machine.temporary.EEDB_Commands");
        Operator.Internal_System_Diagnosis;
        Io.Reset_Output;
        Io.Reset_Input;
        Daemon.Run ("Snapshot");
    end if;
end;
)

RELEASE_RESTORE => (
    Io.Set_Output
       ("!Machine.Release.Archive.Environment.D_12_6_5.Logs.Restore_Release_Log");
    Library.Unfreeze (Existing => "!Copyright_Rational", Response => "<ERRORS>");
    Archive.Restore (Options => "promote new_objects replace",
                     Device => "Release");
    Log.Put_Line ("Restoring help files");
    Library.Delete (Existing => "!Machine.Editor_Data.Session_Switch_Help");
    Library.Delete (Existing => "!Machine.Editor_Data.Help_Data.@");
    Archive.Restore (Options => "Promote, Replace",
                     Device => "Help_Files");
    Io.Reset_Output;
    Log.Filter_Errors
       (Log_File =>
           "!Machine.Release.Archive.Environment.D_12_6_5.Logs.Restore_Release_Log",
        Destination =>
           "!Machine.Release.Archive.Environment.D_12_6_5.Logs.Restore_Release_Log_Summary",
        Auxiliaries => False,
        Warnings => False,
        Exceptions => True);
    Common.Definition
       ("!Machine.Release.Archive.Environment.D_12_6_5.Logs.Restore_Release_Log_Summary");
)

NEW_INIT => (
    Library.Context (To_Be => "!Machine.Release.Environment.D_12_6_5");
    Log.Put_Line ("Starting Install_Machine_Initialization program");
    "!Machine.Release.Environment.D_12_6_5.Load_Procs".Install_Machine_Initialize;
    Common.Definition ("!Machine.Initialization");
)

INSTALL_PRODUCT => (
    Log.Put_Line ("Restoring new RDF initialization procedure");
    Archive.Restore
       (Options => "Promote, Replace", Device => "Rdf_Initialization");
    Library.Context (To_Be => "!Machine.Release.Environment.D_12_6_5");
    System_Utilities.Set_Page_Limit (16_000);
    Log.Put_Line ("Starting Install_Product program");
    "!Machine.Release.Environment.D_12_6_5".Install_Product;
    Log.Put_Line ("Install_Product program completed");
    Common.Definition
       ("!Machine.Release.Environment.D_12_6_5.Logs");
)

SHUTDOWN => (
    Library.Context (To_Be => "!Machine.Release.Environment.D_12_6_5.Load_Procs");
    System_Utilities.Set_Page_Limit (16_000);
    "!Machine.Release.Environment.D_12_6_5.Load_Procs".Reboot_For_New_Release;
)

RESTORE_NOTES => (
    Archive.Restore (Options => "Replace", Device => "Release_Notes");
)

RECORD_INSTALLATION => (
declare
    Product : constant String := Directory_Tools.Naming.Simple_Name
                                    (Directory_Tools.Naming.Full_Name ("^"));
    Release : constant String := Directory_Tools.Naming.Simple_Name
                                    (Directory_Tools.Naming.Full_Name ("$"));
    Product_Info : constant String :=
       "(RELEASE => " & Release & ", DATE => (" &
          Time_Utilities.Image (Time_Utilities.Get_Time,
                                Time_Utilities.Year_Month_Day) &
          "), USER => " & System_Utilities.User_Name &
          '.' & System_Utilities.Session_Name & ")";
    Product_Filename : constant String := "!Machine.Release.Current.Products";
    F : Io.File_Type;
begin
    Io.Append (F, Name => Product_Filename);
    Io.Put_Line (F, Product & " => " & Product_Info);
    Io.Close (F);
    Log.Put_Line ("Recording product " & Product &
                  " current release as " & Release,
                  Profile.Positive_Msg);
end;
)

DESTROY_ARCHIVE => (
    Library.Delete ("!Machine.Release.Archive.Environment.D_12_6_5");
)

STEP_CHECK => (
    -- This must remain the last step in the step file and is used 
    -- as a first level verification of the step file parse and
    -- tape load.
    Log.Put_Line ("Step File parses correctly", Profile.Positive_Msg);
)
DataMuseum.dk

Rational R1000/400 Tapes

⟦c98fff11c⟧ TextFile

Derivation

TextFile
