AMD Manageability Community Blogs - Page 2

cancel
Showing results for 
Search instead for 
Did you mean: 
Announcements
If you are a newcomer, you can post only in the Newcomers Start Here forum. Here's why: DevGurus is a walled community within the larger AMD Community. The "Newcomers Start Here" forum is moderated, to protect our members from spam. A real human being will read your post to make sure it is appropriate for our developers. Once we see that you are a developer, we will add you to the whitelist so you can post anywhere.

AMD Manageability Community Blogs - Page 2

gakamath
Staff
Staff


DASH CLI 2.2 supports new options to enable developers to send request query in JSON format to DASH systems and get the output in JSON format. The output can be interpreted by any programming language supporting JSON format. The output JSON is modeled similar to Redfish Schema published by DMTF.

 

In typical usage, DASH CLI is launched with request JSON. DASH CLI processes the request and forms the response in JSON format. This response is sent back to the launching application.

 

JSON is supported by almost all modern programming languages. Hence it will be easier to add DASH capability into any application or tool with few simple steps. Since the application will be launching DASH CLI, the integration with the application is therefore ‘loosely coupled’. DASH communication, DASH standards compliance, DASH security & stability are encapsulated within DASH CLI. The calling application doesn’t have to know anything about DASH standard.

 

There are two new options in DASH CLI:

  • jdo option: With this flag, DASH request input is taken from command-line and output DASH response is written to console.
  • ji/jo option: With this flag, DASH request input is taken from file and output DASH response is written file.

jdo option is faster since it doesn’t involve any file operation.

 

Before starting

  • Download and install DASH CLI 2.2 version. In this blog, DASH CLI is installed in default path, “C:\Program Files (x86)\DASH CLI 2.2\”
  • Examples are illustrated with Notepad++ Editor. Any other IDE or editor can be used as well.
  • Refer DASH CLI Developer Guide, which is available in DASH CLI installation folder: “C:\Program Files (x86)\DASH CLI 2.2\docs\”, for JSON request & response formats for supported DASH profiles.
  • This blog provides the steps for Windows Power Shell.

 

JDO Flag usage

Using via direct command line

dashcli -jdo

When this command is run, DASH CLI waits for input in JSON format. Once the input is provided, it will be executed by DASH CLI and output of which is written back in JSON format, as shown in the screenshot below.

Image1_JDO.png

After printing the line, “Opening connection to 127.0.0.1:5900 for forwarding from 127.0.0.1:53604”, the command prompt Launches AMD VNC Viewer.

 

Image2_KVMViewer.png

Using JDO option on Windows PowerShell

 

The syntax for JI/JO option on Windows PowerShell is as follows:

 

type input_json.txt | .\dashcli.exe -jdo

 Image3_PowerShell_JDO.png

 

After printing the line, “Opening connection to 127.0.0.1:5900 for forwarding from 127.0.0.1:53400”, the PowerShell Launches AMD VNC Viewer.

 

Image4_PowerShell_JDO_KVMViewer.png

 

Once the viewer is closed, the success JSON is printed on the console.

Ji JO Flag usage

Using via direct command line

dashcli -ji input_json.txt -jo output_json.txt

Here, the file ‘input_json.txt’ has the DASH command in JSON format. DASH CLI executes this command and writes the output in JSON format to file specified by -jo option, which is output_json.txt. Usage is shown in the screenshot below.

Image5_JIJO.png

After printing the line, “Opening connection to 127.0.0.1:5900 for forwarding from 127.0.0.1:53670”, the Command Prompt Launches AMD VNC Viewer.

 

Image6_JIJO_KVMViewer.png

Using JI/JO option on Windows PowerShell

The syntax for JI/JO option on Windows PowerShell is as follows:

 

.\dashcli.exe -ji .\input_json.txt -jo .\output_json.txt

 

 Image7_PowerShell_JIJO.png

After printing the line, “Opening connection to 127.0.0.1:5900 for forwarding from 127.0.0.1:61991”, the PowerShell Launches AMD VNC Viewer.

 

Image8_PowerShell_JIJO_KVMViewer.png

 

Once the viewer is closed, the success JSON is printed on the console.

 

 

In this blog, ‘DASH Computer System Enumerate’ is illustrated. Similarly, other DASH profiles can be accessed by the application by framing the required JSON request. See the ‘DASH CLI Developer Guide’ for JSON format for other supported DASH profiles.

 

For any further query, drop a note below or contact via mail dashsupport@amd.com

 

Reference:

  • DASH CLI Developer Guide (Available in DASH CLI installation folder: “C:\Program Files (x86)\DASH CLI 2.2\docs\”)

 

Useful links:

Related Blogs:

more
3 0 2,735
gakamath
Staff
Staff

Adding DASH to Python Applications

 

DASH CLI 2.2 supports new options to enable developers to send request query in JSON format to DASH systems and get the output in JSON format. The output can be interpreted by any programming language supporting JSON format. The output JSON is modeled similar to Redfish Schema published by DMTF.

 

In typical usage, DASH CLI is launched with request JSON. DASH CLI processes the request and forms the response in JSON format. This response is sent back to the launching application.

 

JSON is supported by almost all modern programming languages. Hence it will be easier to add DASH capability into any application or tool with few simple steps. Since the application will be launching DASH CLI, the integration with the application is therefore ‘loosely coupled’. DASH communication, DASH standards compliance, DASH security & stability are encapsulated within DASH CLI. The calling application doesn’t have to know anything about DASH standard.

 

There are two new options in DASH CLI:

  • jdo option: With this flag, DASH request input is taken from command-line and output DASH response is written to console.
  • ji/jo option: With this flag, DASH request input is taken from file and output DASH response is written file.
  • jdo option is faster since it doesn’t involve any file operation.

 

Before starting

  • Download and install DASH CLI 2.2 version. In this blog, DASH CLI is installed in default path, “C:\Program Files (x86)\DASH CLI 2.2\”
  • Examples are illustrated with Notepad++ Editor. Any other IDE or editor can be used as well.
  • Refer DASH CLI Developer Guide, which is available in DASH CLI installation folder: “C:\Program Files (x86)\DASH CLI 2.2\docs\”, for JSON request & response formats for supported DASH profiles.
  • This blog provides the steps for Python language. Sample code for using -jdo, -ji & -jo options is attached.

 

JDO Flag usage

Using via direct command line

dashcli -jdo

When this command is run, DASH CLI waits for input in JSON format. Once the input is provided, it will be executed by DASH CLI and output of which is written back in JSON format, as shown in the screenshot below.

 

Image1_JDO.png

Using JDO programmatically

Create a sample Python application by following the steps below:

 

Step 1: Create a text file with the name “PythonSample_JDO.py” in Notepad++. Add the import statements from subprocess python library.

 

from subprocess import Popen, PIPE

 

Step 2: Add the two constant members InputFileName and dashCliPath.

 

InputFileName = 'input_json.txt'

dashCliPath = r'C:\Program Files (x86)\DASH CLI 2.2\bin\dashcli.exe'

 

Step 3: Declare a variable named cmd which has the executable path and flag to be passed (-jdo).

 

cmd = [dashCliPath, '-jdo']

 

Step 4: Use one ‘with’ statement to create a handle to DashCLI application, and one more ‘with’ statement to create a file handle to input_json.txt to read the input from file and pass the input to DashCLI application.

 

with Popen(cmd, stdin = PIPE) as dashCliProcessHandle:

    with open(InputFileName, 'r') as myfile:

        input=myfile.read().replace('\n', '')

        print("Input:")

        print(input)

        input_as_bytes = str.encode(input)

        dashCliProcessHandle.stdin.write(input_as_bytes)

    

 

Step 5: Within the outer ‘with’ statement, declare a variable named output to read the output or error messages from the application if any. Then print out the output of the execution.          

    output = ""

    if dashCliProcessHandle.stdout is not None:

        output += dashCliProcessHandle.stdout.read()

    if dashCliProcessHandle.stderr is not None:

        output += dashCliProcessHandle.stderr.read()

    print("Output:")

    print (output)

 

 

Step 6: Surround steps 3 through 5 with commands to indicate program execution with print messages. The entire code at this stage should look like so:

 

from subprocess import Popen, PIPE

InputFileName = 'input_json.txt'

dashCliPath = r'C:\Program Files (x86)\DASH CLI 2.2\bin\dashcli.exe'

 

print("Trying JDO Example...")

cmd = [dashCliPath, '-jdo']

with Popen(cmd, stdin = PIPE) as dashCliProcessHandle:

    with open(InputFileName, 'r') as myfile:

        input=myfile.read().replace('\n', '')

        print("Input:")

        print(input)

        input_as_bytes = str.encode(input)

        dashCliProcessHandle.stdin.write(input_as_bytes)

    

    output = ""

    if dashCliProcessHandle.stdout is not None:

        output += dashCliProcessHandle.stdout.read()

    if dashCliProcessHandle.stderr is not None:

        output += dashCliProcessHandle.stderr.read()

    print("Output:")

    print (output)

 

print("JDO Example Done.")

 

Step 7: Put the following JSON test in input_json.txt file:

 

{"h":"10.138.135.145","u":"Administrator","P":"********","Commands":["enumerate","computersystem"]}

 

 

Step 8: Run the PythonSample_JDO.py script from the console.

 Image2_Step8.png

 

Ji JO Flag usage

Using via direct command line

dashcli -ji input_json.txt -jo output_json.txt

Here, the file ‘input_json.txt’ has the DASH command in JSON format. DASH CLI executes this command and writes the output in JSON format to file specified by -jo option, which is output_json.txt. Usage is shown in the screenshot below.

 

Image3_JIJO.png

Using JI/JO programmatically

Create a sample Python application by following the steps below:

 

Step 1: Create a text file with the name “PythonSample_JIJO.py” in Notepad++. Add the import statements from subprocess python library.

 

from subprocess import Popen, PIPE

 

Step 2: Add the two constant members “InputFileName”, “OutputFileName” and “dashCliPath”.

 

InputFileName = 'input_json.txt'

OutputFileName = 'output_json.txt'

 

dashCliPath = r'C:\Program Files (x86)\DASH CLI 2.2\bin\dashcli.exe'

 

Step 3: Declare a variable named “cmd” which has the executable path and flag to be passed (-ji and -jo), along with the input and output files.

 

cmd = [dashCliPath, '-ji', InputFileName, '-jo', OutputFileName]

 

Step 4: Make a call to the command using “Popen” which executes the command stores output in the file “Output_json.txt”.

 

process = Popen(cmd, shell=True, stdout=PIPE, stderr=PIPE, stdin=PIPE)

 

Step 5: Surround steps 3 and 4 with commands to indicate program execution with print messages. The entire code at this stage should look like so:

 

from subprocess import Popen, PIPE

InputFileName = 'input_json.txt'

OutputFileName = 'output_json.txt'

dashCliPath = r'C:\Program Files (x86)\DASH CLI 2.2\bin\dashcli.exe'

 

print("Trying Ji Jo Example...")

cmd = [dashCliPath, '-ji', InputFileName, '-jo', OutputFileName]

process = Popen(cmd, shell=True, stdout=PIPE, stderr=PIPE, stdin=PIPE)

print("Ji Jo Example Done.")

 

Step 6: Put the following JSON test in input_json.txt file:

 

{"h":"10.138.135.145","u":"Administrator","P":"********","Commands":["enumerate","computersystem"]}

 

Step 7: run the PythonSample_JIJO.py on the console. Then use the type statements to view the input commands as well as the output of execution

 

Image4_Step7.png

 

In this blog, ‘DASH Computer System Enumerate’ is illustrated. Similarly, other DASH profiles can be accessed by the application by framing the required JSON request. See the ‘DASH CLI Developer Guide’ for JSON format for other supported DASH profiles.

 

Attachments:

  1. PythonSample_JDO script
  2. PythonSample_JIJO script

 

For any further query, drop a note below or contact via mail dashsupport@amd.com

 

Reference:

  • DASH CLI Developer Guide (Available in DASH CLI installation folder: “C:\Program Files (x86)\DASH CLI 2.2\docs\”)

 

Useful links:

Related Blogs:

more
4 0 2,497
gakamath
Staff
Staff

A new release of DASH CLI 2.2 is now available.

 

The DASH CLI v2.2 is a command line application used to perform out of band management tasks (power management, asset inventory, alerts, etc.) using DMTF DASH specifications.

 

New features in 2.2 release are:

  • Added 3rd party console enablement support, called developer mode, which takes request in JSON format and gives output in JSON in Redfish format. Following commands are enabled:

o   alertdestination

o   asset

o   bios

o   bootconfig

o   ethernetport

o   fan

o   filtercollection

o   indicationfilter

o   indicationsubscription

o   kvmredirection

o   logentry

o   memory

o   networkport

o   operatingsystem

o   powersupply

o   processor

o   recordlog

o   sensor

o   software

o   textredirection

o   usbredirection

  • Updated previously implemented commands and all corresponding classes with a uniform input output class format in Developer Guide.
  • Updated User Guide with Raw command and added Filter Collection command.
  • Updated Putty code for AMDLink from version 0.69 to 0.71 to incorporate major security updates to Text Redirection and KVM Redirection features

 

The release note is attached, which provide more information on this release and the history of releases.

 

Visit www.amd.com/DASH to download the latest software.

 

For any queries, write a mail to dashsupport@amd.com

more
4 0 1,827
gakamath
Staff
Staff

A new release of AMD Management Console, AMC 3.1 is now available.

 

AMC is a GUI based DASH manageability application for SMB (small & medium business) environments, capable of monitoring and managing up to 500 DMTF’s DASH-compliant client computer systems.

 

New features in 3.1 release are:

  • Remote Access feature: Support launching of In band KVM and Remote Desktop tools.
  • Performance updates to ‘Boot To BIOS’ and ‘Boot To Text’ features.

 

The release note is attached, which provide more information on this release and the history of releases.

 

Visit www.amd.com/DASH to download the latest software.

For any queries, write a mail to dashsupport@amd.com

more
3 0 2,382
gakamath
Staff
Staff

1 DASH Discovery

Discovery is usually the first step in performing DASH Manageability operations on a system.

Latest release of DASH CLI can be downloaded and installed form the site: https://developer.amd.com/tools-for-dmtf-dash/

DASH CLI provides the following modes to perform discovery:

  1. Discover hostname
  2. Discover IP Address
  3. Discover IP Range
  4. Discover Info

1.1 Discover Host-name

Discovery by hostname is the most convenient way to discover systems as hostnames are easier to remember than IP address. A systems IP address may change over time, but hostnames are generally set once.

By DASH Discovery, the user can check for the systems manageability via typing the discover command in the console as follows:

dashcli -h hp6005g discover

The target system responds with the following response, if successful:

DASH system(s) discovered:

        hp6005g:623

DASH Discovery Output has the following attributes:

Fields

Output

Description

Host Name

hp6005g

Host Name of the system on which DASH is enabled

Port

623

Port used for DASH Discovery, 623 by default

 

Screenshot to illustrate Discover Host Name

image001.png

1.2 Discover IP Address

If system’s IP address is known, it can be discovered as follows:

dashcli -h 10.136.6.63 discover

The target system responds with the following response, if successful:

DASH system(s) discovered:

        10.136.6.63:623

DASH Discovery Output has the following attributes:

Fields

Output

Description

IP Address

10.136.6.63

IP Address of the system on which DASH is enabled

Port

623

Port used for DASH Discovery, 623 by default

 

Screenshot to illustrate Discover IP Address

image003.png

1.3 Discover IP Range

If systems within specific IP address range needs to be discovered, the user can type the following command

dashcli -s 10.136.6.62 -e 10.136.6.64 discover

 

Note: Here the flag -s indicates start IP Address and the flag -e indicates end IP Address.

A sample output of such a command look as follows:

Checking 10.136.6.62 ...

Checking 10.136.6.63 ...

Checking 10.136.6.64 ...

 

DASH system(s) discovered:

        10.136.6.63:623

DASH Discovery Output has the following attributes:

Fields

Output

Description

IP Address

10.136.6.63

IP Address of the DASH enabled system

Port

623

Port used for DASH Discovery, 623 by default

 

Screenshot to illustrate Discover IP Range

image005.png

1.4 Discover Info

If the user wants more information regarding the DASH implementation, he can type the following command:

dashcli -h hp6005g discover info

Output:

DASH system(s) discovered:

        hp6005g:623

                DASH Version       : 1.1.0

                Product Vendor     : Broadcom Corporation

                Product Version    : 1.40.0.1 Feb 19 2010 19:54:12

                Protocol Version   : http://schemas.dmtf.org/wbem/wsman/1/wsman.xsd

                                     http://schemas.dmtf.org/wbem/wsman/1/wsman/secprofile/http/digest

                                     http://schemas.dmtf.org/wbem/wsman/1/wsman/secprofile/http/spnego-kerberos

                                     http://schemas.dmtf.org/wbem/wsman/1/wsman/secprofile/https/digest

                                     http://schemas.dmtf.org/wbem/wsman/1/wsman/secprofile/https/spnego-kerberos

The Discovery Info command has the following attributes:

Fields

Description

Host Name

Dash enabled system host name or IP Address

Port

Port used for DASH Discovery, 623 by default

DASH Version

Version of DASH protocol implemented

Product Vendor

NIC vendor implementing the DASH Protocol

Product Version

Version of DASH implementation

Protocol Version

Schema Version used for evaluation of the output

Security Profile(s)

The Set of security profile definitions supported

 

Screenshot to Illustrate Discover Info

image007.png

This concludes our discussion of Discovery on DASH CLI

Appendix - AMC

AMC (AMD Management Console) is a GUI tool used for DASH Manageability. AMC can be Installed from the site: https://developer.amd.com/tools-for-dmtf-dash/

For more details regarding Discovery in AMC, refer the blog: https://community.amd.com/docs/DOC-2193

For Users of AMC software, Discovery information is also available in AMC. Upon adding a new system with Discover button.

image009.png

Discovery Info can also be seen in the Inventory section:

 image011.png

For any further query, drop a note below or contact via mail: dashsupport@amd.com

 

Useful links:

more
8 0 4,915
gakamath
Staff
Staff

DASH CLI 2.1 supports new options to enable developers to send request query in JSON format to DASH systems and get the output in JSON format. The output can be interpreted by any programming language supporting JSON format. The output JSON is modeled similar to Redfish Schema published by DMTF.

 

In typical usage, DASH CLI is launched with request JSON. DASH CLI processes the request and forms the response in JSON format. This response is sent back to the launching application.

 

JSON is supported by almost all modern programming languages. Hence it will be easier to add DASH capability into any application or tool with few simple steps. Since the application will be launching DASH CLI, the integration with the application is therefore ‘loosely coupled’. DASH communication, DASH standards compliance, DASH security & stability are encapsulated within DASH CLI. The calling application doesn’t have to know anything about DASH standard.

 

There are two new options in DASH CLI:

  • jdo option: With this flag, DASH request input is taken from command-line and output DASH response is written to console.
  • ji/jo option: With this flag, DASH request input is taken from file and output DASH response is written file.

jdo option is faster since it doesn’t involve any file operation.

 

Before starting

  • Download and install DASH CLI 2.1 version. In this blog, DASH CLI is installed in default path, “C:\Program Files (x86)\DASH CLI 2.1\”
  • Examples are illustrated with Visual Studio 2017. But any other IDE or editor can be used.
  • Refer DASH CLI Developer Guide, which is available in DASH CLI installation folder: “C:\Program Files (x86)\DASH CLI 2.1\docs\”, for JSON request & response formats for supported DASH profiles.
  • This blog provides the steps for C# .NET language. Sample code for using -jdo, -ji & -jo options is attached.

JDO Flag usage

Using via direct command line

     dashcli -jdo

When this command is run, DASH CLI waits for input in JSON format. Once the input is provided, it will be executed by DASH CLI and output of which is written back in JSON format, as shown in the screenshot below.

JDO Input Masked.png

Using JDO programmatically

Create a sample C# application by following the steps below:

 

Step 1: Create a new project in Visual Studio by selecting from the Menu “File” > “New” > “Project”

 image001.png

Step 2: Select “Visual C#” -> “Console App (.net Framework)”. Name the application “SampleJDO” and click “OK” button.

 image002.png

 

Step 3: Add the two constant members dashCliDirectory and dashCliPath in “Program.cs” file.

        private static readonly string dashCliDirectory = @"C:\Program Files (x86)\DASH CLI 2.1\bin\";

        private static readonly string dashCliPath = dashCliDirectory + @"dashcli.exe";

 

Step 4: Add the using statements to include “System.Diagnostics” and “System.IO” as these will be referenced in the upcoming code.

 

using System.Diagnostics;

using System.IO;

 

Step 5: Define the functions “JdoExample” and “RunDashCli” as shown below:

 

        static void JdoExample() {

            string memStdIn, memStdOut = String.Empty, memStdErr = String.Empty;

            string inputJsonFile = @"input_json.txt";

            memStdIn = Convert.ToString(File.ReadAllText(inputJsonFile));

            Console.WriteLine("Input: ");

            Console.WriteLine(memStdIn);

            string arguments = @"-jdo";

            int returnCode = RunDASHCli(arguments, memStdIn, out memStdOut, out memStdErr);

            Console.WriteLine("Output: ");

            Console.Write(memStdOut);

            //'memStdout' has the result in JSON format

        }

 

        static int RunDASHCli(string arguments, string memStdIn, out string memStdOut, out string memStdErr) {

            memStdOut = String.Empty;

            memStdErr = String.Empty;

 

            int exitCode = 1;

            Process process = new Process();

            StreamWriter streamWriter = null;

            StreamReader streamOutReader = null;

            StreamReader streamErrReader = null;

 

            process.StartInfo.UseShellExecute = false;

            process.StartInfo.WindowStyle = ProcessWindowStyle.Normal;

            process.StartInfo.WorkingDirectory = dashCliDirectory;

            process.StartInfo.RedirectStandardInput = true;

            process.StartInfo.RedirectStandardOutput = true;

            process.StartInfo.RedirectStandardError = true;

            process.StartInfo.FileName = dashCliPath;

            process.StartInfo.Arguments = arguments;

            try {

                process.Start();

                streamOutReader = process.StandardOutput;

                streamWriter = process.StandardInput;

                streamErrReader = process.StandardError;

                streamWriter = process.StandardInput;

                streamWriter.WriteLine(memStdIn);

                streamWriter.Close();

                memStdOut = streamOutReader.ReadToEnd();

                memStdErr = streamErrReader.ReadToEnd();

                process.WaitForExit();

                exitCode = process.ExitCode;

                streamOutReader.Close();

                streamErrReader.Close();

            } catch (Exception) {

                exitCode = -1;

            } finally {

                process.Close();

            }

            return exitCode;

        }

 

Step 6: Call “JdoExample” function in the “Main” function and surround the call with messages to indicate start and stop of call like so:

 

            Console.WriteLine("Trying JdoExample ...");

            JdoExample();

            Console.WriteLine("JdoExample done.");

 

The entire code at this stage should look like so:

 

using System;

using System.Diagnostics;

using System.IO;

 

namespace SampleJDO {

    class Program {

        private static readonly string dashCliDirectory = @"C:\Program Files (x86)\DASH CLI 2.1\bin\";

        private static readonly string dashCliPath = dashCliDirectory + @"dashcli.exe";

        static void Main(string[] args) {

            Console.WriteLine("Trying JdoExample ...");

            JdoExample();

            Console.WriteLine("JdoExample done.");

        }

        static void JdoExample() {

            string memStdIn, memStdOut = String.Empty, memStdErr = String.Empty;

            string inputJsonFile = @"input_json.txt";

            memStdIn = Convert.ToString(File.ReadAllText(inputJsonFile));

            Console.WriteLine("Input: ");

            Console.WriteLine(memStdIn);

            string arguments = @"-jdo";

            int returnCode = RunDASHCli(arguments, memStdIn, out memStdOut, out memStdErr);

            Console.WriteLine("Output: ");

            Console.Write(memStdOut);

            //'memStdout' has the result in JSON format

        }

 

        static int RunDASHCli(string arguments, string memStdIn, out string memStdOut, out string memStdErr) {

            memStdOut = String.Empty;

            memStdErr = String.Empty;

 

            int exitCode = 1;

            Process process = new Process();

            StreamWriter streamWriter = null;

            StreamReader streamOutReader = null;

            StreamReader streamErrReader = null;

 

            process.StartInfo.UseShellExecute = false;

            process.StartInfo.WindowStyle = ProcessWindowStyle.Normal;

            process.StartInfo.WorkingDirectory = dashCliDirectory;

            process.StartInfo.RedirectStandardInput = true;

            process.StartInfo.RedirectStandardOutput = true;

            process.StartInfo.RedirectStandardError = true;

            process.StartInfo.FileName = dashCliPath;

            process.StartInfo.Arguments = arguments;

            try {

                process.Start();

                streamOutReader = process.StandardOutput;

                streamWriter = process.StandardInput;

                streamErrReader = process.StandardError;

                streamWriter = process.StandardInput;

                streamWriter.WriteLine(memStdIn);

                streamWriter.Close();

                memStdOut = streamOutReader.ReadToEnd();

                memStdErr = streamErrReader.ReadToEnd();

                process.WaitForExit();

                exitCode = process.ExitCode;

                streamOutReader.Close();

                streamErrReader.Close();

            } catch (Exception) {

                exitCode = -1;

            } finally {

                process.Close();

            }

            return exitCode;

        }

    }

}

 

Step 7: In step 5, the added function “JdoExample”, has defined the input JSON File as input_json.txt. This declaration assumes that input_json.txt is in the same path as the location of the executable. As the default configuration in Visual studio points to Debug folder, please navigate to the debug folder. Upon building the project, the Output window gives the location of the Debug folder.

 image003.png

Step 8: Put the following JSON test in input_json.txt file:

 

     {"h":"hp705g4-3","u":"admin","P":"adminPass","Commands":["discover"]}

 

Step 9: Run the SampleJDO.exe application form the console.

 image004.png

Ji JO Flag usage

Using via direct command line

     dashcli -ji input_json.txt -jo output_json.txt

Here, the file ‘input_json.txt’ has the DASH command in JSON format. DASH CLI executes this command and writes the output in JSON format to file specified by -jo option, which is output_json.txt. Usage is shown in the screenshot below.

JIJO Input Masked.png

Using JI/JO programmatically

Create a sample C# application by following the steps below:

 

Step 1: Create a new project in Visual Studio by selecting from the Menu “File” > “New” > “Project”

 image001.png

Step 2: Select “Visual C#” -> “Console App (.net Framework)”. Name the application “SampleJiJO” and click “OK” button.

 image005.png

 

Step 3: Add the two constant members dashCliDirectory and dashCliPath in “Program.cs” file.

        private static readonly string dashCliDirectory = @"C:\Program Files (x86)\DASH CLI 2.1\bin\";

        private static readonly string dashCliPath = dashCliDirectory + @"dashcli.exe";

 

Step 4: Add the using statements to include “System.Diagnostics” and “System.IO” as these will be referenced in the upcoming code.

 

using System.Diagnostics;

using System.IO;

 

Step 5: Define the functions “JiJoExample” and “RunDashCli” as shown below:

 

        static void JiJoExample() {

            string AppPath = System.IO.Path.GetDirectoryName(System.Reflection.Assembly.GetEntryAssembly().Location) + "\\";

            string inputJsonFile = AppPath + @"input_json.txt";

            string outputJsonFile = AppPath + @"output_json.txt";

            Console.WriteLine("Input File: " + inputJsonFile);

            Console.WriteLine("Output File: " + outputJsonFile);

            string arguments = String.Format("-ji {0} -jo {1}", inputJsonFile, outputJsonFile);

            int returnCode = RunDASHCli(arguments);

            //'outputJsonFile' has the result in JSON format

        }

 

        static int RunDASHCli(string arguments, string memStdIn, out string memStdOut, out string memStdErr) {

            memStdOut = String.Empty;

            memStdErr = String.Empty;

 

            int exitCode = 1;

            Process process = new Process();

            StreamWriter streamWriter = null;

            StreamReader streamOutReader = null;

            StreamReader streamErrReader = null;

 

            process.StartInfo.UseShellExecute = false;

            process.StartInfo.WindowStyle = ProcessWindowStyle.Normal;

            process.StartInfo.WorkingDirectory = dashCliDirectory;

            process.StartInfo.RedirectStandardInput = true;

            process.StartInfo.RedirectStandardOutput = true;

            process.StartInfo.RedirectStandardError = true;

            process.StartInfo.FileName = dashCliPath;

            process.StartInfo.Arguments = arguments;

            try {

                process.Start();

                streamOutReader = process.StandardOutput;

                streamWriter = process.StandardInput;

                streamErrReader = process.StandardError;

                streamWriter = process.StandardInput;

                streamWriter.WriteLine(memStdIn);

                streamWriter.Close();

                memStdOut = streamOutReader.ReadToEnd();

                memStdErr = streamErrReader.ReadToEnd();

                process.WaitForExit();

                exitCode = process.ExitCode;

                streamOutReader.Close();

                streamErrReader.Close();

            } catch (Exception) {

                exitCode = -1;

            } finally {

                process.Close();

            }

            return exitCode;

        }

 

Step 6: Call “JiJoExample” function in the “Main” function and surround the call with messages to indicate start and stop of call like so:

            Console.WriteLine("Trying JiJoExample ...");

            JiJoExample();

            Console.WriteLine("JiJoExample done.");

 

The entire code at this stage should look like so:

 

using System;

using System.Diagnostics;

using System.IO;

 

namespace SampleJiJO {

    class Program {

        private static readonly string dashCliDirectory = @"C:\Program Files (x86)\DASH CLI 2.1\bin\";

        private static readonly string dashCliPath = dashCliDirectory + @"dashcli.exe";

        static void Main(string[] args) {

            Console.WriteLine("Trying JiJoExample ...");

            JiJoExample();

            Console.WriteLine("JiJoExample done.");

        }

        static void JiJoExample() {

            string AppPath = System.IO.Path.GetDirectoryName(System.Reflection.Assembly.GetEntryAssembly().Location) + "\\";

            string inputJsonFile = AppPath + @"input_json.txt";

            string outputJsonFile = AppPath + @"output_json.txt";

            Console.WriteLine("Input File: " + inputJsonFile);

            Console.WriteLine("Output File: " + outputJsonFile);

            string arguments = String.Format("-ji {0} -jo {1}", inputJsonFile, outputJsonFile);

            int returnCode = RunDASHCli(arguments);

            //'outputJsonFile' has the result in JSON format

        }

        static int RunDASHCli(string arguments) {

            string Out, Err;

            return RunDASHCli(arguments, string.Empty, out Out, out Err);

        }

 

        static int RunDASHCli(string arguments, string memStdIn, out string memStdOut, out string memStdErr) {

            memStdOut = String.Empty;

            memStdErr = String.Empty;

 

            int exitCode = 1;

            Process process = new Process();

            StreamWriter streamWriter = null;

            StreamReader streamOutReader = null;

            StreamReader streamErrReader = null;

 

            process.StartInfo.UseShellExecute = false;

            process.StartInfo.WindowStyle = ProcessWindowStyle.Normal;

            process.StartInfo.WorkingDirectory = dashCliDirectory;

            process.StartInfo.RedirectStandardInput = true;

            process.StartInfo.RedirectStandardOutput = true;

            process.StartInfo.RedirectStandardError = true;

            process.StartInfo.FileName = dashCliPath;

            process.StartInfo.Arguments = arguments;

            try {

                bool processStarted = process.Start();

                streamOutReader = process.StandardOutput;

                streamWriter = process.StandardInput;

                streamErrReader = process.StandardError;

                streamWriter = process.StandardInput;

                streamWriter.WriteLine(memStdIn);

                streamWriter.Close();

                memStdOut = streamOutReader.ReadToEnd();

                memStdErr = streamErrReader.ReadToEnd();

                process.WaitForExit();

                exitCode = process.ExitCode;

                streamOutReader.Close();

                streamErrReader.Close();

            } catch (Exception) {

                exitCode = -1;

            } finally {

                process.Close();

            }

            return exitCode;

        }

    }

}

 

Step 7: In step 5, the added function “JiJoExample”, has defined the input JSON File as input_json.txt and output JSON File as output_json.txt. This declaration assumes that input_json.txt is in the same path as the location of the executable. As the default configuration in Visual studio points to Debug folder, please navigate to the debug folder. Upon building the project, the Output window gives the location of the Debug folder.

 image006.png

Step 8: Put the following JSON test in input_json.txt file:

 

     {"h":"hp705g4-3","u":"admin","P":"adminPass","Commands":["discover"]}

 

Step 9: Run the “SampleJiJO.exe” application form the console.

 image007.png

Step 10: Check the content of the “output_json.txt” file using “type” command on the console

 image008.png

In this blog, DASH Discovery is illustrated. Similarly, other DASH profiles can be accessed by the application by framing the required JSON request. See the ‘DASH CLI Developer Guide’ for JSON format for other supported DASH profiles.

Attachments:

  1. SampleJDO solution
  2. SampleJIJO solution

 

For any further query, drop a note below or contact via mail dashsupport@amd.com

 

Reference:

  • DASH CLI Developer Guide (Available in DASH CLI installation folder: “C:\Program Files (x86)\DASH CLI 2.1\docs\”)

 

Useful links:

Related Blogs:

more
6 0 4,494
gakamath
Staff
Staff

HP 705 G4 EliteDesk supports AMD KVM solution based on DASH. This blog is on enabling KVM on that desktop, and using the feature via AMC (AMD Management Console).

The recommended software version for KVM are:

  • BIOS: Q06 Ver. 02.04.01
  • Realtek Ethernet driver: 10.23.1003.2017

This blog outlines the procedure to update the HP DASH system to these software versions.

Quick steps:

  1. Download latest BIOS from HP support site.
  2. Install the BIOS image on the DASH system.
  3. Enable DASH option in the BIOS setup.
  4. Verify Ethernet controller driver version and update if required.
  5. Try DASH KVM use-case from AMC or DASH CLI.

Note that this blog is on getting KVM working. It assumes DASH is working on the HP 705 G4 DASH system.

Step1: Download the latest BIOS:

At the time of writing this document the latest BIOS information is Q06 Ver. 02.04.01:

1) Navigate to the URL: https://support.hp.com/in-en/drivers/selfservice/hp-elitedesk-705-g4-microtower-pc/21351257/model/21...

2) Select the OS as Windows and the version as Windows 10 (x64) then click on ‘Change’ Button

image001.png

3) From the list of items select the ‘+’ marked against BIOS. This expands the list and shows 3 versions of Bios namely Q05, Q06 and Q09.

image002.png

4) Then click on Download against Q06. This downloads the executable sp92135.exe

image003.png

Step 2: Install the BIOS image on the Target:

Copy the executable (sp92135.exe) to the Target machine. Right click on the executable and run it as administrator.

image004.png

This launches the InstallShield Wizard which explains the purpose of the application. Click on the “Next >” button to proceed.

image005.png

Read the license agreement thoroughly. Upon agreeing, click on “I accept the terms in the license agreement” option. Then click on the “Next >” button.

image006.png

Decide on a suitable location to save the files required for flashing.

image007.png

If the folder already exists, it will prompt for an overwrite confirmation. Users can choose to select “Yes to All”, if they are sure that all the files need to be changed.

image008.png

After completion of this step, automatically the HP Firmware Upgrade and Recovery application is launched.

Select Update option if you wish to Update the current target machine itself. Then click on the “Next >” button to proceed.

image009.png

The screen shows the current version of BIOS running as well as the version the Firmware will be upgraded to. Click on the “Next >” Button to proceed.

image010.png

This takes us to the Success screen, that initiates the firmware update process upon clicking “Restart” button.

image011.png

Upon restarting, the user is taken to the BIOS screen which mentions the version to which the BIOS is currently being updated to.

BIOS Update progress

image012.jpg

BIOS Update progress

Then the message “Updating PEIA Region” is shown along with a progress bar.

image013.jpg

The user is then prompted to “Please be patient”, till the BIOS Update operation completes.

image014.jpg

After this process, the startup screen is shown with the currently running BIOS version. We can see here that the version mentioned as 02.04.01 matches with the update version mentioned before the update.

image015.jpg

Step 3: Enable DASH from BIOS:

Restart the system and hit “Esc” button till the system goes into BIOS – startup Menu screen.

image016.png

Click on Bios Setup (F10). This takes us to the Main Tab.

image017.png

Click on the “Advanced” Tab. And click on “System Options”.

image018.png

Look for the option “AMD DASH”. Then ensure that it is ticked.

image019.png

Return to “Main” Tab. Click on “Save Changes and Exit”.

image020.png

This shows the screen confirming with us if we really want to save the changes. Click on “Yes” and continue.

image021.png

Step 4: Verify Ethernet Controller Driver Version.

Right Click on the Start Button and Select Device Manager

image022.png

Expand Network Adapters, then right click on Realtek Driver followed by clicking “Properties”

image023.png

Then click on “Driver” Tab and verify the “Driver Version”

VerifyDriverVersion.png

The driver version must be 10.23.1003.2017 or higher. Available at the following link.

Note: To get the latest Realtek Ethernet Controller driver, please contact HP Customer Support.

The Realtek Dash Client will appear in the tray icon

Realtek Screenshots.PNG

Upon opening the Realtek Client it shows window with current Firmware version and DASH Client Version

Realtek Client Screenshot.png

Step 5: Launch KVM from AMC

In AMC, 'Discover' the HP DASH System. After the DASH system is listed, click on “BOOT TO BIOS” ribbon icon.

image025.png

This launches the window where KVM information is shown. From here click Start to initiate the Boot to BIOS.

image026.png

This initiates the system restart Process:

image027.png

The HP DASH system boots to the BIOS setup screen and shortly afterwards, AMD VNC Viewer is launched. It redirects the Keyboard, Video and Mouse from HP DASH system on to the VNC viewer.

image028.png

Equivalent DASH CLI command:

  • dashcli -h systemname -p 623 -S http -a digest -u Administrator -P DashPassword enumerate kvmredirection
  • dashcli -h systemname -p 623 -S http -a digest -u Administrator -P DashPassword-t kvmredirection[0] startkvm

'startkvm' will launch the VNC viewer.

Links:

1) HP 705 G4 product page: https://store.hp.com/us/en/pdp/hp-elitedesk-705-g4-microtower-pc

2) AMC, DASH CLI: http://www.amd.com/DASH

Contact us:

Site (www.amd.com/DASH)

Email (dashsupport@amd.com)

more
6 0 9,738
msdivy
Staff
Staff

The new builds of AMPS, AMC & DASH CLI are available for download. The latest versions are,

  • AMD Management Plugin for SCCM - AMPS 4.1.0.0918
  • AMD Management Console - AMC 3.0.0.0454
  • DASH Command Line Interface - DASH CLI 2.0.0.0536

The key features in all of these releases are,

  • KVM Redirection support – with Boot To BIOS screen workflow.
  • Performance tuning and network enhancements to KVM use case
  • Support Windows Server 2016 & latest Windows 10 OS
  • Support DASH CIM Schema 2.48.0

The AMPS release has these updates,

  • Support version 1802, 1706, 1702, 1610, 1606, 1602 & 1511 of SCCM

AMC release has these updates,

  • Support Windows 10 update 1803

DASH CLI release has these new commands,

  • ‘enumerate’ - Show all instances of KVM service
  • ‘show’ - Show information of an instance of KVM Service
  • ‘enable’ - Enable KVM redirection service
  • ‘disable’ - Disable KVM redirection service
  • ‘connect’ - Connect to running VNC server in KVM engine
  • startkvm’ - Boot to BIOS workflow (enable the service, reboot and connect to VNC server)

Download link: http://www.amd.com/DASH#downloads

Note: Platform and DASH LoM must support KVM profile. Please check with your system vendor for KVM support.

more
1 0 3,316