DataMuseum.dk

Presents historical artifacts from the history of:

Rational R1000/400 Tapes

This is an automatic "excavation" of a thematic subset of
artifacts from Datamuseum.dk's BitArchive.

See our Wiki for more about Rational R1000/400 Tapes

Excavated with: AutoArchaeologist - Free & Open Source Software.


top - download
Index: ┃ S T

⟦81d058f47⟧ TextFile

    Length: 8647 (0x21c7)
    Types: TextFile
    Names: »STEPS«

Derivation

└─⟦5f3412b64⟧ Bits:30000745 8mm tape, Rational 1000, ENVIRONMENT 12_6_5 TOOLS 
    └─ ⟦91c658230⟧ »DATA« 
        └─⟦this⟧ 

TextFile

INSTALL_X_INTERFACE => (do_step("AUTHORIZATION_CHECK,
                                 INSTALL_PRODUCT,
                                 RECORD_INSTALLATION",
                 "!Machine.Release.Archive.X_Interface.Release10_9_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 ("NAME => (X Interface)");
    Token_Iter : Pp.Iterator := Pp.Parse ("NAME => (X Interface)");
    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;
    if Get_Site /= "" and then not Pp.Done (Token_Iter) then
        Error := 0;
        Log.Put_Line ("Checking Token Count");
        declare
            Limit, Current, Buy_Out : Natural;
        begin
            while not Pp.Done (Token_Iter) loop
                "!Machine.Release.Archive.X_Interface.Release10_9_0.Command_Data".
                   Token_Information
                   (Product_Name (Token_Iter), Limit, Buy_Out, Current);
                if Limit = 0 then
                    Error := Error + 1;
                    Log.Put_Line
                       ("No tokens (sessions) for " &
                        Product_Name (Token_Iter) &
                        " have been authorized.  Do not proceed until you have authorized tokens for this product",
                        Profile.Error_Msg);
                elsif (Buy_Out /= Current) and Current = Limit then
                    Log.Put_Line
                       ("Tokens (Sessions) have been authorized for " &
                        Product_Name (Token_Iter) & ", but all are in use",
                        Profile.Error_Msg);
                    Log.Put_Line
                       ("Have users which are using these tokens log off (and then back on) before continuing",
                        Profile.Error_Msg);
                    Show_Tokens (Product_Filter =>
                                    Product_Name (Token_Iter));
                else
                    Log.Put_Line (Product_Name (Token_Iter) &
                                  " has available tokens",
                                  Profile.Positive_Msg);
                end if;
                Pp.Next (Token_Iter);
            end loop;
            if Error /= 0 then
                Do_Step ("PROMPT=AUTHORIZE_TOKEN");
            end if;
        end;
    else
        Log.Put_Line
           ("Machine has not been configured for per session pricing (product tokens)." &
            "  Skipping product token check");
    end if;
end;            
)

INSTALL_PRODUCT => (
       if "!Implementation".Product_Authorization.Is_Registered
                  ("x interface") then
                Log.Put_Line ("x interface" & " is authorized",
                              Profile.Note_Msg);
                Do_Step ("RESTORE_NOTES");
                Do_Step ("RELEASE_RESTORE");
       else
            Log.Put_Line ("Need to Authorize " & "X Interface",
                              Profile.Error_Msg);
            Log.Put_Line
               ("Do not proceed until all these products have been authorized",
                Profile.Error_Msg);
            Do_Step ("PROMPT=AUTHORIZE_PRODUCT");
       end if;
           
)

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;
)

CLEANUP => (
    Library.Delete ("!Machine.Release.Archive.X_Interface.Release10_9_0");
)

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


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

INSTALL_ALL_KEYMAPS => (               
declare
    Second_Value : Integer;
    Last_Value : Integer;
begin
    Common.Definition ("!Machine.Release.X_Interface.Release10_9_0");
    Library.Context (To_Be => "!Machine.Release.x_interface.Release10_9_0");
    System_Utilities.Set_Page_Limit (16_000);
    Second_Value := "!machine.release.x_interface.release10_9_0".
                       Rxi_Install.Terminal_Type'Pos
                       ("!machine.release.x_interface.release10_9_0".
                        Rxi_Install.Terminal_Type'First) + 1;
    Last_Value := "!machine.release.x_interface.release10_9_0".
                     Rxi_Install.Terminal_Type'Pos
                     ("!machine.release.x_interface.release10_9_0".
                      Rxi_Install.Terminal_Type'Last);
    "!machine.release.x_interface.release10_9_0".
       Rxi_Install.Machine_Editor_Data_Files
       (Keyboard =>  
           "!machine.release.x_interface.release10_9_0".
              Rxi_Install.Terminal_Type'First,
        Suppress_Rxi_Files => False);  
    for I in Second_Value .. Last_Value loop
        "!machine.release.x_interface.release10_9_0".
           Rxi_Install.Machine_Editor_Data_Files
           (Keyboard =>  
               "!machine.release.x_interface.release10_9_0".
                  Rxi_Install.Terminal_Type'Val (I),
            Suppress_Rxi_Files => True);
    end loop;
end;
)
    
AUTHORIZE_PRODUCT => (
    "!Implementation".Product_Authorization.Register
            (Product_Name => "X Interface",
             Authorization_Code => ">> Code <<");
)

AUTHORIZE_TOKEN => (
    Accept_Tokens (Product => [STRING-expression],
                   Donation => [POSITIVE-expression],
                   Resulting_Count => [POSITIVE-expression],
                   Code => [STRING-expression],
                   Response => "<PROFILE>");
)

D1_AUTHORIZATION_CHECK => (
       if "!Implementation".Product_Authorization.Is_Registered
                  ("x interface") then
                Log.Put_Line ("x interface" & " is authorized",
                              Profile.Note_Msg);
       else
            Log.Put_Line ("Need to Authorize " & "X Interface",
                              Profile.Error_Msg);
            Log.Put_Line
               ("Do not proceed until all these products have been authorized",
                Profile.Error_Msg);
            Do_Step ("PROMPT=AUTHORIZE_PRODUCT");
       end if;
           
)