DataMuseum.dk

top - download

    Length: 6763 (0x1a6b)
    Types: TextFile
    Notes: R1k Text-file segment

└─⟦8527c1e9b⟧ Bits:30000544 8mm tape, Rational 1000, Arrival backup of disks in PAM's R1000
    └─ ⟦5a81ac88f⟧ »Space Info Vol 1« 
        └─⟦91275e3bb⟧ 
            └─⟦this⟧ 

TextFile

INSTALL_X_LIBRARY => (Do_Step("AUTHORIZATION_CHECK,
                               CONFIGURATION_CHECK,
                               RELEASE_RESTORE,    
                               RESTORE_NOTES,
                               RESTORE_DOCUMENTATION,
                               INSTALL_PRODUCT,
                               RECORD_INSTALLATION",
"!Machine.Release.Archive.X_Library.release6_0_0.Command_Data.Steps");
)

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, X_Library");
    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;
)


CONFIGURATION_CHECK => (
    Io.Put_Line ("EXECUTING CONFIGURATION : "& 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");
    Operator.Internal_System_Diagnosis;    
    Io.Reset_Input;
)

RELEASE_RESTORE => (
    Io.Set_Output
       ("!Machine.Release.Archive.X_Library.Release6_0_0.Logs.Restore_Release_Log");
    Archive.Restore (Options => "promote, replace", Device => "Release");
    Io.Reset_Output;
    Log.Filter_Errors
       (Log_File =>
           "!Machine.Release.Archive.X_Library.Release6_0_0.Logs.Restore_Release_Log",
        Destination =>
           "!Machine.Release.Archive.X_Library.Release6_0_0.Logs.Restore_Release_Log_Summary",
        Auxiliaries => False,
        Warnings => False,
        Exceptions => True);
    Common.Definition
       ("!Machine.Release.Archive.X_Library.Release6_0_0.Logs.Restore_Release_Log_Summary");
)

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

RESTORE_DOCUMENTATION => (
    Archive.Restore (Device => "Documentation");
)

INSTALL_PRODUCT => (
declare
    Delta1 : constant Boolean := 
      System_Utilities.System_Boot_Configuration(
              (System_Utilities.System_Boot_Configuration'First + 3)) = '0';
    Ops : String (1 .. 256);
    X_Demos, X_Testing, X_Tools, Activity, Primary: Boolean := True;

    function Get_Input (Querie_String : String) return Boolean is
    begin
        loop
            Io.Put_Line ("");
            Io.Put (Querie_String);
            declare
                Accepts : constant String := Io.Get_Line;
            begin
                return (Accepts'Length = 0 or else
                        (Accepts (Accepts'First) = 'y' or
                         Accepts (Accepts'First) = 'Y'));
            end;
        end loop;
    end Get_Input;
begin  
    loop  
        X_Demos := Get_Input ("Should X_Demos subsystems be restored? [y] ");
        X_Testing := Get_Input
                        ("Should X_Testing subsystems be restored? [y] ");
        X_Tools := Get_Input ("Should X_Tools subsystems be restored? [y] ");
        Activity :=
           Get_Input
              ("Should system-wide activity be updated to include all restored subsystems? [y] ");
        Primary :=
           Get_Input
              ("Should the subsystems be restored as primary susbsystems? [y] ");
        exit when Get_Input ("Are all of the above anwers correct? [y] ");
    end loop;
    "!Machine.Release.X_Library.Release6_0_0".Install_Product 
              (Log_File => "INSTALL_PRODUCT_LOG",
                Options => "DELTA1 => " & boolean'image(delta1) &
                           ",DELTA2 => " & boolean'image(not delta1) &
                           ",CONVERT_TO_D2 => " & boolean'image(not delta1) &
                           ",X_DEMOS => " & boolean'image(x_demos) &
                           ",X_TESTING => " & boolean'image(x_testing) &
                           ",X_TOOLS => " & boolean'image(x_tools) &
                           ",UPDATE_ACTIVITY => " & boolean'image(activity) &
                           ",PRIMARY => " & boolean'image(primary) ,
              Response => "<VERBOSE> RAISE_ERROR");
    link.edit ("!Machine.Release.Current.Commands");
    links.insert ("!Tools.X_Windows.@.rev6@.units.[env@,comm@].@'C(Proc_Spec)");
    Common.Definition
       ("!Machine.Release.X_Library.Release6_0_0.Install_Product_Log_Problems");
end;
)

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
    Log.Put_Line ("Allowing unlimited logins", Profile.Positive_Msg);
    Operator.Limit_Login;
    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;
)

CLEANUP => (
    Library.Delete ("!Machine.Release.[X_Library,Archive].[X_Library.Release6_0_0,Release6_0_0.Segments]",
                    Limit => "<ALL_WORLDS>");
)

AUTHORIZE_PRODUCT => (
    "!Implementation".Product_Authorization.Register
            (Product_Name => ">>Product Name<<",
             Authorization_Code => ">> Code <<");
)