AMD Manageability Community Blogs

cancel
Showing results for 
Search instead for 
Did you mean: 

AMD Manageability Community Blogs

Staff
Staff

A new release of AMD Management Plugin for SCCM, AMPS 5.0 is now available.

 

AMPS is a GUI plugin for Microsoft Endpoint Configuration Manager based to enable monitoring and managing of DMTF’s DASH-compliant client computer systems.

 

New features in 5.0 release are:

  • Added support for Realtek F Series KVM
  • Fix for multiple bugs and performance improvement.
  • Support for ‘Next Single Use Boot’ configuration in Boot Control Profile

 

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
1 0 325
Staff
Staff

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

 

AMC is a GUI based DASH manageability application for small business environments, capable of monitoring and managing DMTF’s DASH-compliant client computer systems.

 

New features in 6.0 release are:

  • Added additional inventory DASH Profile to the following profiles - PCI Device, Physical Computer System View, Indicator LED, IP Configuration, Platform Watchdog & Media Redirection
  • Upgraded the following libraries - CPP Rest SDK, OpenSSL, JSON CPP, SSH.net
  • Fix for multiple bugs and performance improvement.
  • Support for ‘Next Single Use Boot’ configuration in Boot Control Profile

 

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
0 0 330
Staff
Staff

A new release of DASH CLI 3.0 is now available.

 

The DASH CLI 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 3.0 release are:

  • Improved security and application performance
  • Support for enumeration for the following DASH profiles:
    • Indicator LED
    • IP Configuration
    • Media Redirection
    • PCI Device
    • Physical Computer System View
    • Platform Watchdog
    • Service Processor
  • Support for ‘Next Single Use Boot’ configuration in Boot Control Profile

 

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
1 0 311

DASH CLI 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 like 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 does not require 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 to a file.

jdo option is faster since it does not involve in any file operation.

 

Before starting

  • Download and install DASH CLI 3.0 version. In this blog, DASH CLI is installed in default path, “C:\Program Files (x86)\DASH CLI 3.0\”
  • 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 3.0\docs\”, for JSON request & response formats for supported DASH profiles.
  • This blog provides the steps for C++ language sample code for using -jdo, -ji & -jo options.

 

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.

pastedImage_1.png

Using JDO programmatically

Create a sample C++ Console application by following the steps below:

 

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

 pastedImage_4.png  

Step 2: Select “Visual C++” -> “Console App”. Name the application “JDOApp” and click “OK” button.

 pastedImage_5.png

 

Step 3: Add the two constant variables in main function which contains path to DASHCLI and arguments to it

      const char szArgs[] = (" -jdo ");

      const char szAppPath[] = ("C:\\Program Files (x86)\\DASH CLI 3.0\\bin\\dashcli.exe");

 

Step 4: Include windows, fstream and iostream header files as these will be referenced in the upcoming code.

 

#include <windows.h>

#include <fstream>

#include <iostream>

 

Step 5: Define the below functions

  • RunDashCLIWithJDO – This function takes 3 arguments Path to DASHCLI application, arguments and commands for DASHCLI. This function creates pipes, process to execute the DASHCLI with provided arguments and commands.
  • ReadFromDashCLIProcess – This function reads the output of DASHCLI process and prints to parent stdout.

 

int RunDashCLIWithJDO(const char szAppPath[], const char szArgs[], const char szCommands[])

{

      int iRetVal = 0;

 

      // Create PIPE for sending commands and reading output from DASHCLI process.

      SECURITY_ATTRIBUTES seAttr;

      // Set the bInheritHandle flag true so pipe handles are inherited.

      seAttr.nLength = sizeof(SECURITY_ATTRIBUTES);

      seAttr.bInheritHandle = true;

      seAttr.lpSecurityDescriptor = NULL;

 

      // Create a pipe for the DASHCli process's STDOUT.

      if (!CreatePipe(&ghDashCmdOUTRd, &ghDashCmdOUTWr, &seAttr, 0))

      {

            cout << "Stdout CreatePipe failed." << endl;

            iRetVal = -1;

      }

 

      // Ensure the read handle to the pipe for STDOUT is not inherited.

      if (!SetHandleInformation(ghDashCmdOUTRd, HANDLE_FLAG_INHERIT, 0))

      {

            cout << "Stdout SetHandleInformation failed." << endl;

            iRetVal = -1;

      }

 

      // Create a pipe for the DASHCli process's STDIN.

      if (!CreatePipe(&ghDashCmdINRd, &ghDashCmdINWr, &seAttr, 0))

      {

            cout << "Stdin CreatePipe failed." << endl;

            iRetVal = -1;

      }

 

      // Ensure the write handle to the pipe for STDIN is not inherited.

      if (!SetHandleInformation(ghDashCmdINWr, HANDLE_FLAG_INHERIT, 0))

      {

            cout << "Stdin SetHandleInformation failed." << endl;

            iRetVal = -1;

      }

 

      PROCESS_INFORMATION piProcInfo;

      STARTUPINFOA siStartInfo;

 

      // Set up members of the PROCESS_INFORMATION structure.

      ZeroMemory(&piProcInfo, sizeof(PROCESS_INFORMATION));

 

      // Set up members of the STARTUPINFO structure.

      // This structure specifies the STDIN and STDOUT handles for redirection.

      ZeroMemory(&siStartInfo, sizeof(STARTUPINFO));

      siStartInfo.cb = sizeof(STARTUPINFO);

      siStartInfo.hStdError = ghDashCmdOUTWr;

      siStartInfo.hStdOutput = ghDashCmdOUTWr;

      siStartInfo.hStdInput = ghDashCmdINRd;

      siStartInfo.dwFlags |= STARTF_USESTDHANDLES;

 

      // Create process with application path of DASHCLI and required arguments list.

      // If an error occurs, return -1

      if (iRetVal != 0 || !CreateProcessA(szAppPath, const_cast<LPSTR>(szArgs), NULL, NULL, true, 0, NULL, NULL, &siStartInfo, &piProcInfo))

      {

            std::cout << "Process/Pipe creation failed to execute DashCLI" << std::endl;

            iRetVal = -1;

      }

      else

      {

            // Sending commands to DashCLI

            std::cout << szCommands;

            unsigned long  dwRead = strlen(szCommands), dwWritten;

            WriteFile(ghDashCmdINWr, szCommands, dwRead, &dwWritten, NULL);

 

            // Wait for the process to complete execution.

            WaitForSingleObject(piProcInfo.hProcess, INFINITE);

 

            CloseHandle(piProcInfo.hProcess);

            CloseHandle(piProcInfo.hThread);

      }

 

      return iRetVal;

 

void ReadFromDashCLIProcess(void)

{

      unsigned long  dwRead, dwWritten;

      char chBuf[BUFSIZE];

      bool bSuccess = false;

      void * hParentStdOut = GetStdHandle(STD_OUTPUT_HANDLE);

 

      bSuccess = ReadFile(ghDashCmdOUTRd, chBuf, BUFSIZE, &dwRead, NULL);

 

      if (bSuccess && dwRead > 0)

      {

            WriteFile(hParentStdOut, chBuf, dwRead, &dwWritten, NULL);

      }

}

 

Step 6: Call “RunDashCLIWithJDO” and “ReadFromDashCLIProcess” function in “main” function by reading input from input_json.txt file.

 

char szCommands[BUFSIZE];

 

      // Read input commands to DashCLI from json file

      std::ifstream infile;

      infile.open("input_json.txt");

      infile >> szCommands;

      strcat_s(szCommands, "\r\n");      // Append carriage return and new line characters to input.

 

      cout << "Running DashCLI with JDO" << endl;

      if (0 == RunDashCLIWithJDO(szAppPath, szArgs, szCommands))

      {

            ReadFromDashCLIProcess();

      } 

 

The entire code at this stage should look like as below:

 

#include <windows.h>

#include <fstream>

#include <iostream>

 

using namespace std;

 

#define BUFSIZE 4096

 

void * ghDashCmdINRd = NULL;

void * ghDashCmdINWr = NULL;

void * ghDashCmdOUTRd = NULL;

void * ghDashCmdOUTWr = NULL;

 

// Create a child process to run DashCLI and redirect STDIN/STDOUT through pipes.

// Returns: -1 if process creation is failed.

//       0 if process creation is successful.

int RunDashCLIWithJDO(const char szAppPath[], const char szArgs[], const char szCommands[])

{

      int iRetVal = 0;

 

      // Create PIPE for sending commands and reading output from DASHCLI process.

      SECURITY_ATTRIBUTES seAttr;

      // Set the bInheritHandle flag true so pipe handles are inherited.

      seAttr.nLength = sizeof(SECURITY_ATTRIBUTES);

      seAttr.bInheritHandle = true;

      seAttr.lpSecurityDescriptor = NULL;

 

      // Create a pipe for the DASHCli process's STDOUT.

      if (!CreatePipe(&ghDashCmdOUTRd, &ghDashCmdOUTWr, &seAttr, 0))

      {

            cout << "Stdout CreatePipe failed." << endl;

            iRetVal = -1;

      }

 

      // Ensure the read handle to the pipe for STDOUT is not inherited.

      if (!SetHandleInformation(ghDashCmdOUTRd, HANDLE_FLAG_INHERIT, 0))

      {

            cout << "Stdout SetHandleInformation failed." << endl;

            iRetVal = -1;

      }

 

      // Create a pipe for the DASHCli process's STDIN.

      if (!CreatePipe(&ghDashCmdINRd, &ghDashCmdINWr, &seAttr, 0))

      {

            cout << "Stdin CreatePipe failed." << endl;

            iRetVal = -1;

      }

 

      // Ensure the write handle to the pipe for STDIN is not inherited.

      if (!SetHandleInformation(ghDashCmdINWr, HANDLE_FLAG_INHERIT, 0))

      {

            cout << "Stdin SetHandleInformation failed." << endl;

            iRetVal = -1;

      }

 

      PROCESS_INFORMATION piProcInfo;

      STARTUPINFOA siStartInfo;

 

      // Set up members of the PROCESS_INFORMATION structure.

      ZeroMemory(&piProcInfo, sizeof(PROCESS_INFORMATION));

 

      // Set up members of the STARTUPINFO structure.

      // This structure specifies the STDIN and STDOUT handles for redirection.

      ZeroMemory(&siStartInfo, sizeof(STARTUPINFO));

      siStartInfo.cb = sizeof(STARTUPINFO);

      siStartInfo.hStdError = ghDashCmdOUTWr;

      siStartInfo.hStdOutput = ghDashCmdOUTWr;

      siStartInfo.hStdInput = ghDashCmdINRd;

      siStartInfo.dwFlags |= STARTF_USESTDHANDLES;

 

      // Create process with application path of DASHCLI and required arguments list.

      // If an error occurs, return -1

      if (iRetVal != 0 || !CreateProcessA(szAppPath, const_cast<LPSTR>(szArgs), NULL, NULL, true, 0, NULL, NULL, &siStartInfo, &piProcInfo))

      {

            std::cout << "Process/Pipe creation failed to execute DashCLI" << std::endl;

            iRetVal = -1;

      }

      else

      {

            // Sending commands to DashCLI

            std::cout << szCommands;

            unsigned long  dwRead = strlen(szCommands), dwWritten;

            WriteFile(ghDashCmdINWr, szCommands, dwRead, &dwWritten, NULL);

 

            // Wait for the process to complete execution.

            WaitForSingleObject(piProcInfo.hProcess, INFINITE);

 

            CloseHandle(piProcInfo.hProcess);

            CloseHandle(piProcInfo.hThread);

      }

 

      return iRetVal;

}

 

// Read output from the DashCLI process

// and write to the parent STDOUT.

void ReadFromDashCLIProcess(void)

{

      unsigned long  dwRead, dwWritten;

      char chBuf[BUFSIZE];

      bool bSuccess = false;

      void * hParentStdOut = GetStdHandle(STD_OUTPUT_HANDLE);

 

      bSuccess = ReadFile(ghDashCmdOUTRd, chBuf, BUFSIZE, &dwRead, NULL);

 

      if (bSuccess && dwRead > 0)

      {

            WriteFile(hParentStdOut, chBuf, dwRead, &dwWritten, NULL);

      }

}

 

int main(int argc, char* argv[])

{

      const char szArgs[] = (" -jdo ");

 

      // Path to DashCLI application.

      const char szAppPath[] = ("C:\\Program Files (x86)\\DASH CLI 3.0\\bin\\dashcli.exe");

 

      char szCommands[BUFSIZE];

 

      // Read input commands to DashCLI from json file

      std::ifstream infile;

      infile.open("input_json.txt");

      infile >> szCommands;

      strcat_s(szCommands, "\r\n");      // Append carriage return and new line characters to input.

 

      cout << "Running DashCLI with JDO" << endl;

      if (0 == RunDashCLIWithJDO(szAppPath, szArgs, szCommands))

      {

            ReadFromDashCLIProcess();

      }

      cout << "DashCLI execution with JDO is complete." << endl;

 

      return 0;

} 

Step 7: In step 6, main function reads input for JDO from a JSON File (input_json.txt). It assumes that input_json.txt is present in the working directory of the project if the application is running through Visual Studio or it should be present in the exe application path.

 

Step 8: Contents of JSON text file can be any of the input from Developer guide like a discover command as shown below.

 

     {"h":"HP705G1","u":"adminUserName","P":"adminPassword","Commands":["discover"]}

 

Step 9: Run the JDOApp.exe application from the console.

 pastedImage_6.png

 

Other Commands:

Discover Info through DashCLI JDO

This is to discover the given host and get the list of security profiles supported by the dash target system.

Update the input_json.txt with discover and info commands as below

   {"h":"HP705G1","u":"adminUserName","P":"adminPassword","Commands":["discover","info"]}

Repeat Step 9. Output will contain the discovery information under info tag and security profiles under SecurityProfile tag.

 pastedImage_7.png

Power Status through DashCLI JDO

This is to get the current power status of a dash target system.

Update the input_json.txt with power status commands as below

{"h":"HP705G1","u":"adminUserName","t":"computersystem[0]","P":"adminPassword","Commands":["power","status"]}

Output will contain the current power status of the dash system. Power status will be in shown in the PowerState tag.

 pastedImage_8.png

Change Power Status through DashCLI JDO

This is to change the power status of a dash target system.

Update the input_json.txt with power and available state commands as below

   {"h":"HP705G1","u":"adminUserName","P":"adminPassword","Commands":["power","sleep"]}

Output will contain the power change status of the dash system. ErrorCode tag will contain the status of the power operation 0 if power operation is successful. ErrorMessage will contain more information on the status of the operation as shown below

 pastedImage_9.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.

pastedImage_10.png

Using JI/JO programmatically

Create a sample C++ console application by following the steps below:

 

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

 pastedImage_11.png

Step 2: Select “Visual C++” -> “Console App”. Name the application “JiJoApp” and click “OK” button.

 pastedImage_12.png

 

Step 3: Add the two constant members which stores DashCLI application path  and DashCLI arguments in main function.

      const char szArgs[] = (" -ji input_json.txt -jo output_json.txt");

      const char szAppPath[] = ("C:\\Program Files (x86)\\DASH CLI 3.0\\bin\\dashcli.exe"); 

 

Step 4: Include required header files like windows.h and iostream

 

#include <windows.h>

#include <iostream>

 

Step 5: Define a function “RunDashCLIWithJiJO” which creates a process and executes DASHCLI application with JIJO parameters as shown below:

 

void RunDashCLIWithJiJO(const char szAppPath[], const char szArgs[])

{

      PROCESS_INFORMATION piProcInfo;

      STARTUPINFOA siStartInfo;

 

      // Set up members of the PROCESS_INFORMATION structure.

      ZeroMemory(&piProcInfo, sizeof(PROCESS_INFORMATION));

 

      // Set up members of the STARTUPINFO structure.

      ZeroMemory(&siStartInfo, sizeof(STARTUPINFO));

      siStartInfo.cb = sizeof(STARTUPINFO);

 

      // Create process with application path of DASHCLI and required arguments list.

      if (!CreateProcessA(szAppPath, (LPSTR)szArgs, NULL, NULL, true, 0, NULL, NULL, &siStartInfo, &piProcInfo))

      {

            cout << "Process creation failed to execute DashCLI" << std::endl;

      }

      else

      {

            // Wait for the process to complete execution.

            WaitForSingleObject(piProcInfo.hProcess, INFINITE);

 

            CloseHandle(piProcInfo.hProcess);

            CloseHandle(piProcInfo.hThread);

            cout << "DashCLI execution complete." << endl;

      }

}

 

Step 6: Call “RunDashCLIWithJiJO” function in the “main” function

            RunDashCLIWithJiJO(szAppPath, szArgs);

 

The entire code at this stage should look like so:

 

#include <windows.h>

#include <iostream>

 

using namespace std;

 

// Create a child process to run DashCLI and redirect STDIN/STDOUT through pipes.

void RunDashCLIWithJiJO(const char szAppPath[], const char szArgs[])

{

      PROCESS_INFORMATION piProcInfo;

      STARTUPINFOA siStartInfo;

 

      // Set up members of the PROCESS_INFORMATION structure.

      ZeroMemory(&piProcInfo, sizeof(PROCESS_INFORMATION));

 

      // Set up members of the STARTUPINFO structure.

      ZeroMemory(&siStartInfo, sizeof(STARTUPINFO));

      siStartInfo.cb = sizeof(STARTUPINFO);

 

      // Create process with application path of DASHCLI and required arguments list.

      if (!CreateProcessA(szAppPath, (LPSTR)szArgs, NULL, NULL, true, 0, NULL, NULL, &siStartInfo, &piProcInfo))

      {

            cout << "Process creation failed to execute DashCLI" << std::endl;

      }

      else

      {

            // Wait for the process to complete execution.

            WaitForSingleObject(piProcInfo.hProcess, INFINITE);

 

            CloseHandle(piProcInfo.hProcess);

            CloseHandle(piProcInfo.hThread);

            cout << "DashCLI execution complete." << endl;

      }

}

 

int main(int argc, char* argv[])

{

      const char szArgs[] = (" -ji input_json.txt -jo output_json.txt");

 

      // Path to DashCLI application.

      const char szAppPath[] = ("C:\\Program Files (x86)\\DASH CLI 3.0\\bin\\dashcli.exe");

 

      cout << "Running DashCLI with JIJO" << endl;

      RunDashCLIWithJiJO(szAppPath, szArgs);

 

      return 0;

} 

Step 7: In step 6, to call function “RunDashCLIWithJiJO”, DASHCLI argument expects the input JSON file which is input_json.txt to be present in the working directory if the sample application is running from Visual Studio or to be present in the exe path if the application is running from the command line.

 

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

 

{"h":"HP705G1","u":"AdminUserName","P":"AdminPassword","Commands":["discover"]}

 

Step 9: Run the “JiJoApp.exe” application from the console.

 pastedImage_13.png

Step 10: Check the content of the “output_json.txt” file using “type” command on the console as shown in the above command. Output_json.txt file will contain the output of DASHCLI for the commands in input_json.txt.

 

Other Commands:

Discover Info through DashCLI JiJO

This is to discover the given host and get the list of security profiles supported by the dash target system.

Update the input_json.txt with discover and info commands as below

{"h":"HP705G1","u":"adminUserName","P":"adminPassword","Commands":["discover","info"]}

Repeat Step 9 & 10. Output will be stored in json format in output_json.txt. This contains the discovery information under info tag and security profiles under SecurityProfile tag as show in the below snapshot.

 pastedImage_14.png

Power Status through DashCLI JiJO

This is to get the current power status of a dash target system.

Update the input_json.txt with power status commands as below

{"h":"HP705G1","u":"adminUserName","P":"adminPassword","t":"computersystem[0]","Commands":["power","status"]}

Repeat above steps 9 & 10, output will be stored in the output_json.txt which contains the current power status of the dash system. Power status will be in shown in the PowerState tag.

 pastedImage_15.png

Change Power Status through DashCLI JDO

This is to change the power status of a dash target system.

Update the input_json.txt with power and available state commands as below

{"h":"HP705G1","u":"adminUserName","P":"adminPassword","Commands":["power","sleep"]}

Output will contain the power change status of the dash system. ErrorCode tag will contain the status of the power operation 0 if power operation is successful. ErrorMessage will contain more information on the status of the operation as shown below

 pastedImage_16.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:

  • JDOApp solution
  • JiJoApp 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 3.0\docs\”)

 

Useful links:

 

Related Blogs:

more
1 0 325
Staff
Staff

This blog outlines the procedure of enabling DASH in bios and Lenovo T495 has been used for reference.

Quick Steps:

  1. Download latest BIOS for Lenovo-T495 system
  2. Upgrade the Bios n the Lenovo-T495 system
  3. Enable DASH option in Bios
  4. Verify the DASH FW in windows in Realtek Dash Client tool
  5. Verification using DASHCLI tool

Step 1: Download the latest BIOS:

The latest BIOS version available on the web is R12ET49W (1.19):

  1. Navigate to the URL: https://support.lenovo.com/us/en/downloads/ds539877
  2. Download the exe file

pastedImage_1.png

Step 2: Install the BIOS Image on Target

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

pastedImage_2.png

This launches the Install Shield Wizard select language as English

pastedImage_3.png

Click Next


pastedImage_4.png

Accept the License Agreement and click Next

pastedImage_5.png

Click on Install

pastedImage_6.png

Once Finished exit the wizard by clicking Finish

pastedImage_7.png

Further the ThinkPad Bios Flash Update Utility asks for option Select” Update ThinkPad BIOS”
pastedImage_8.png


Further the Bios update is initiated and once completed Restart the system

Step 3: Enable DASH option in the Bios

Once the system is restarted after the Bios gets upgraded, Press F1 to move to Setup Utility

pastedImage_14.png

Switch to security Tab and go to Dash Configuration setting

pastedImage_15.png

Enter DASH Configuration setting and Enable the DASH Support option

pastedImage_16.png

Press F10 to Save and Exit

Step 4: Verify the DASH FW in windows in Realtek Dash Client tool

Once system is rebooted to windows, the required Drivers and Realtek Dash Client is installed.
The DASH FW version can be seen in right end corner of tray icon

pastedImage_18.png

Step 5: Verification Using DASHCLI Tool
After DASH is enabled in system, DASHCLI can be used to verify some of DASH related features

DASHCLI Commands:
1.To verify DASH System is DASH Capable:
dashcli.exe -h <ipaddress> -u <username> -P <password> discover
2. To verify power options available in target system:
dashcli.exe -h <ipaddress> -u <username> -P <password> -t computersystem[0] power availablestates

Useful Links:
1. Downloading DASHCLI & AMC
https://developer.amd.com/tools-for-dmtf-dash/ 
2. Discovering DASH Systems using DASHCLI
https://community.amd.com/community/devgurus/dmtf-dash/blog/2019/04/02/discovering-dash-systems-usin... 
3. Discovering DASH system using AMC
https://community.amd.com/docs/DOC-2193 



more
3 0 2,663
Staff
Staff

1. The functionality has been implemented using WMI interface and are embedded as scripts which can be downloaded       using below link:

      https://support.lenovo.com/us/en/solutions/ht100612 

2. Cscript is required for execution which can be found in below path in windows installed systems

      C:\windows\system32\cscript.exe

3. Below command is used to list current bios settings:

      cscript.exe ListAll.vbs

4. To Enable/Disable DASH in bios, Use the below command accordingly:

      cscript.exe SetConfig.vbs DashEnabled Enable (To Enable DASH)

      cscript.exe SetConfig.vbs DashEnabled Disable (To Disable DASH)

5. Restart the system for changes to get reflected.

more
1 0 2,078
Staff
Staff

   1. Download Bios Configuration Utility from the link below:

https://ftp.hp.com/pub/caps-softpaq/cmit/HP_BCU.html

   2. Once installed the exe file can be found in “C:\Program Files (x86) \HP\BIOS Configuration Utility.

   3. Open the path in command prompt 

   4. To Fetch the current bios configuration, use the below command

         BiosConfigUtility64.exe/get:<filename.txt>”

   5. Once the .txt file is generated, one can see the bios settings in the file.

   6. Grep for” AMD DASH” and to make changes update the field with *Enable (enable DASH) or *Disable (Disable          DASH).

         Example: AMD DASH
                           Disable
                           *Enable

   7. Once the settings are modified, execute below command for changes to get reflected:

         BiosConfigUtility64.exe/set:<filename.txt>”

   8. Reboot the system for changes to get reflected.

more
0 0 2,068
Staff
Staff

This document outlines the steps required to configure DASH systems for HTTPS communication using self-signed certificates.

 

Requirements

1. Download and install the latest available OpenSSL package (http://www.openssl.org/).

a. Ensure openssl.exe is in %PATH%

b. Ensure that the environment variables has the variable “OPENSSL_CONF”

OPENSSL_CONF

C:\Program Files\OpenSSL-Win64\bin\cnf\openssl.cnf

2. Sample ini is specified in Appendix A. Save the contents as openssl.ini and modify the file based on your organization requirement.

a. Organization wide certificate: A common certificate can be generated and installed on all DASH systems in the organization (by giving Common Name as *.myorg.com). For an organization wide option, under “alt_names” section, add the key “DNS.1” Eg,

DNS.1   = *.myorg.com

b. Per device certificate: A per device certificate can be generated and installed on that particular device (Eg: dash-system.myorg.com). Per device certificate can be generated on alternate names of the systems and also on IP address. For per per device option, under “alt_names” section, add value for key “DNS.1”, “DNS.2 and “IP.1”. Eg,

DNS.1   = dash-system.myorg.com

DNS.2   = dash-system

IP.1    = 10.10.10.100

3. NIC Management Controller specific requirements are mentioned in Section D

Note: The steps below are tested with OpenSSL 1.1.1d version.

 


 

Section A: Generate Root certificate

A Root certificate is common to the whole organization. It is generated only once and installed in the certificate store.

 

1)    Create folders & copy openssl.ini

mkdir DASHCert 

cd DASHCert 

copy ..\openssl.ini DASHCert 

mkdir newcerts private

2)    Create requisite files

echo 01 > serial 

copy /y nul index.txt

 

3)    Create root certificate

Note: For ‘Common Name’, specify the name of the root authority. For instance like 'DASH Root Authority'.

openssl genrsa -out private/cakey.pem 1024

 

openssl req -new -x509 -extensions v3_ca -key private/cakey.pem -out cacert.pem -days 3650 -sha256 -config ./openssl.ini

 

openssl x509 -in cacert.pem -out DASHCA.crt

 


 

Section B: Add root certificate to certificate store on the system with DASH Console

Root certicate must be installed in the certificate store on all console systems where DASH applications like DASH CLI, AMD Management Console and AMPS are installed.

 

1. Windows OS system with DASH Console

1. Copy DASHCA.crt to DASH Console.

2. Import to certificate store:

a. Right click on DASHCA.crt and select 'Install Certificate'

b. Select “Local Machine” as Store Location

c. Click Next and select 'Place all certificates in the following store'

d. Click Browse and select 'Trusted Root Certification Authorities'

e. Click Next & Finish

 

2. Ubuntu OS system with DASH Console

1. Copy DASHCA.crt to DASH Console

sudo mkdir /usr/share/ca-certificates/extra

 

sudo cp DASHCA.crt /usr/share/ca-certificates/extra

 

sudo dpkg-reconfigure ca-certificates

 

2. A new UI window will be open -> Select YES

3. Give space to select the DASHCA.crt in Trusted certificates

sudo update-ca-certificates

 

3. Fedora OS system with DASH Console

1. Copy DASHCA.crt to DASH Console

sudo cp DASHCA.crt /etc/pki/ca-trust/source/anchors

 

sudo update-ca-trust

 


 

Section C: Generate organization-wise or per-device certificate

Continuation of the steps from Section A.

1)    Create certificate signing request

Note: For ‘Common Name’, specify the generic (Eg: *.myorg.com).

openssl req -new -nodes -out req.pem -sha256 -extensions v3_req -config ./openssl.ini

 

2)    Sign certificate

openssl ca -out cert.pem -extensions v3_req -config ./openssl.ini -infiles req.pem

 

3)    Strip readable text

move cert.pem tmp.pem

 

openssl x509 -in tmp.pem -out cert.pem

 

4)    Convert to DER format

openssl rsa -in key.pem -inform PEM -out DASHKey.der -outform DER

 

openssl x509 -in cert.pem -inform PEM -out DASHCert.der -outform DER

 

 

 

 

 


 

Section D: Import certificate on the DASH System

Executing the commands below will over-write the existing certificate details. Procedure to install certificate on a DASH System varies based on Management Controller:

1)    Realtek Management Controller

Note: Sample config.xml is specified in Appendix B

1. Ensure DASHConfigRT folder is present in your DASH Application folder

2. Copy DASHConfigRT folder to the DASH System

3. Copy the files ‘DASHKey.der’ & ‘DASHCert.der’ to DASH System

4. Copy the file config.xml to the same folder as DASHConfigRT.exe and update config.xml as required.

5. Using DASHConfigRT, install the certifiate files with one of the commands:

a. Configure username, password and install certificate

DASHConfigRT.exe -xf:config.xml -certSmiley Very HappyASHCert.der -privSmiley Very HappyASHKey.der

b. Only to update the certificates

DASHConfigRT.exe -certSmiley Very HappyASHCert.der -privSmiley Very HappyASHKey.der

2)    Broadcom Management Controller

Note: Sample config.xml is specified in Appendix C

1. Ensure DASHConfig folder is present in your DASH Application folder

2. Copy DASHConfig folder to the DASH System

3. Copy the files ‘DASHKey.der’ & ‘DASHCert.der’ to DASH System

4. Copy the file config.xml to the same folder as DASHConfig.exe and update config.xml as required.

5. Using DASHConfig, install the certificate files with the commands:

DASHConfig.exe -xf:config.xml


 

Section E: Verification

To verify the certificate installed correctly and DASH HTTPS is working.

 

1)    Via browser

Open the link https://dash-system.myorg.com:664/ in either Chrome or Internet Explorer. The browser must report the site as secure and the TLS certificate must match with that generated in Section A.

 

2)    Via DASH CLI

Run a DASH CLI https command without -C option. DASH CLI must provide the output without any error.

dashcli -h dash-system.myorg.com -p 664 -S https -a digest -u admin -P adminpass -t computersystem[0] power status

 


 

 

Appendix A - Sample openssl.ini

# OpenSSL configuration file.

#----Begin----

# Establish working directory.

dir = .

 

[ ca ]

default_ca = CA_default

 

[ CA_default ]

serial = $dir/serial

database = $dir/index.txt

new_certs_dir = $dir/newcerts

certificate = $dir/cacert.pem

private_key = $dir/private/cakey.pem

default_days = 3650

default_md = sha256

preserve = no

email_in_dn = no

nameopt = default_ca

certopt = default_ca

policy = policy_match

 

[ policy_match ]

countryName = match

stateOrProvinceName = match

organizationName = match

organizationalUnitName = optional

commonName = supplied

emailAddress = optional

 

[ req ]

default_bits = 1024

default_keyfile = key.pem

default_md = sha256

string_mask = nombstr

distinguished_name = req_distinguished_name

 

[ req_distinguished_name ]

# Variable name Prompt string

#---------------------- ----------------------------------

0.organizationName = Organization Name (company)

organizationalUnitName = Organizational Unit Name (department, division)

emailAddress = Email Address

emailAddress_max = 40

localityName = Locality Name (city, district)

stateOrProvinceName = State or Province Name (full name)

countryName = Country Name (2 letter code)

countryName_min = 2

countryName_max = 2

commonName = Common Name (hostname, IP, or your name)

commonName_max = 64

# Default values for the above, for consistency and less typing.

# Variable name Value

#------------------------------ ------------------------------

0.organizationName_default       = MyOrg Inc

organizationalUnitName           = IT

countryName_default              = IN

stateOrProvinceName_default      = KA

localityName_default             = Bangalore

emailAddress_default             = it@myorg.com

organizationalUnitName_default   = IT Department

commonName_default               = *.myorg.com

 

 

[ alt_names ]

# Hostname of target with FQDN can also be entered in the form *.domain.com

DNS.1      = *.myorg.com

#DNS.2     = dash-system.myorg.com

#DNS.3     = dash-system

# IP address can be allowed with the IP Key

#IP.1      = 10.10.10.100

 

 

[ v3_ca ]

basicConstraints = CA:TRUE

subjectKeyIdentifier = hash

authorityKeyIdentifier = keyid:always,issuer:always

keyUsage = digitalSignature, nonRepudiation, keyEncipherment, dataEncipherment, keyAgreement, keyCertSign

subjectAltName = @alt_names

 

[ v3_req ]

basicConstraints = CA:FALSE

keyUsage = digitalSignature, nonRepudiation, keyEncipherment, dataEncipherment, keyAgreement, keyCertSign

subjectAltName = @alt_names

#----End----


 

Appendix B - Sample config.xml for Realtek Management Controller

 

<?xml version="1.0" encoding="utf-8" ?>

<DASHPROVISIONSETTINGS>

      <MANAGEMENTTARGET>

           <GLOBAL>

                 <HTTPS>

                       <ENABLESUPPORT>true</ENABLESUPPORT>

                      <TCPIPPORT>664</TCPIPPORT>

                 </HTTPS>

                 <HTTP>

                       <ENABLESUPPORT>true</ENABLESUPPORT>

                      <TCPIPPORT>623</TCPIPPORT>

                 </HTTP>

           </GLOBAL>

           <USERS>

                 <USER>

                      <USERID>admin</USERID>

                       <PASSWORD>adminPass</PASSWORD>

                      <ENABLE>true</ENABLE>

                      <ROLES>

                            <ROLE>Administrator Role</ROLE>

                      </ROLES>

                 </USER>

           </USERS>

      </MANAGEMENTTARGET>

</DASHPROVISIONSETTINGS>

 


 

Appendix C - Sample config.xml for Broadcom Management Controller

 

<?xml version="1.0" encoding="utf-8" ?>

<DASHPROVISIONSETTINGS>

      <MANAGEMENTTARGET>

           <GLOBAL>

                 <HTTPS>

                       <ENABLESUPPORT>true</ENABLESUPPORT>

                      <TCPIPPORT>664</TCPIPPORT>

                      <HTTPREALM>Broadcom Management Service</HTTPREALM>

                      <HTTPSTARGETTOCONSOLE>

                          <CERTIFICATEPATH>DASHCert.der</CERTIFICATEPATH>

                      </HTTPSTARGETTOCONSOLE>

                 </HTTPS>

                 <HTTP>

                       <ENABLESUPPORT>true</ENABLESUPPORT>

                      <TCPIPPORT>623</TCPIPPORT>

                 </HTTP>

           </GLOBAL>

           <USERS>

                 <USER>

                      <USERID>admin</USERID>

                       <PASSWORD>adminPass</PASSWORD>

                      <ENABLE>true</ENABLE>

                      <ROLES>

                            <ROLE>Administrator Role</ROLE>

                      </ROLES>

                 </USER>

           </USERS>

      </MANAGEMENTTARGET>

</DASHPROVISIONSETTINGS>

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

more
3 0 2,094
Staff
Staff

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

 

AMC is a GUI based DASH manageability application for small business environments, capable of monitoring and managing DMTF’s DASH-compliant client computer systems.

 

New features in 4.0 release are:

  • Option to check for new AMC versions and upgrade automatically.
  • VNC Viewer features are enhanced for KVM Redirection workflow.
  • Option provided to trust or reject self-signed TLS certificates for HTTPS DASH communication.
  • Additional assets profiles listed in Inventory window.
  • Option to select local ISO images for USB Redirection, Firmware Upgrade and Boot to Text workflows.
  • DASHConfigRT is packaged with AMC to configure Realtek based DASH systems.
  • Following packages were updated (CPP REST SDK-2.10.14, OpenSSL-1.1.1d, JSONCPP-1.9.0, CIM Schema-2.52, Putty-0.73).
  • Fix for multiple bugs and performance improvement.

 

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 1,978
Staff
Staff

DASH CLI application can help in out of band management of DASH enabled systems using any of hostname, IPv4 address or IPv6 address. Here is a comparison of the usage between calling the same commands from DASH CLI.

In the below examples we have considered a system with the following properties:

  • Hostname – dash-system
  • IPv4 address – 192.168.0.12
  • IPv6 address – 2002:a8a:87b3:0:200:1aff:fe1c:4520

DASH CLI can be downloaded from the AMD page https://developer.amd.com/tools-for-dmtf-dash/ 

Command 1: Discovery Info

HostName

Input

dashcli -h dash-system discover info

Output

DASH system(s) discovered:

        desktop-picasso:623

                DASH Version       : 1.1.0

                Product Vendor     : Broadcom Corporation

                Product Version    : 3.5.0.9 Nov  2 2017 03:18:19

                Protocol Version   :

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

                Security Profile(s): http://schemas.dmtf.org/wbem/wsman/1/wsman/secprofile/http/digest

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

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

IPv4

Input

dashcli -h 192.168.0.12 discover info

Output

DASH system(s) discovered:

        192.168.0.12:623

                DASH Version       : 1.1.0

                Product Vendor     : Broadcom Corporation

                Product Version    : 3.5.0.9 Nov  2 2017 03:18:19

                Protocol Version   :

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

                Security Profile(s):

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

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

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

IPv6

Input

dashcli -h 2002:a8a:87b3:0:200:1aff:fe1c:4520 discover info

Output

DASH system(s) discovered:

        2002:a8a:87b3:0:200:1aff:fe1c:4520:623

                DASH Version       : 1.1.0

                Product Vendor     : Broadcom Corporation

                Product Version    : 3.5.0.9 Nov  2 2017 03:18:19

                Protocol Version   :

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

                Security Profile(s):

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

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

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

 

Command 2: Enumerate Computer System

HostName

Input

dashcli -h dash-system -u admin -P adminpass enumerate computersystem

Output

Computer System Instance 0

Name                                : 12345678-1234-5678-90ab-cddeefaabbcc

Element Name                        : Computer System

Primary Owner                       :

Primary Owner Contact               :

Enabled State                       : Enabled

Requested State                     : No Change

Current Power State                 : On

Requested Power State               : Off - Hard Graceful

PowerOn Time                        : N/A

Dedicated To                        : Laptop

Supported Power Change capabilities : Power State Settable,

                                      Power Cycling Supported,

                                      HW Reset Supported,

                                      Graceful Shutdown Supported

Supported Power States              : Other,

                                      On,

                                      Sleep - Light,

                                      Sleep -Deep,

                                      Power Cycle (Off - Soft),

                                      Hibernate (Off - Soft),

                                      Off - Soft,

                                      Master Bus Reset,

                                      Off - Soft Graceful,

                                      Master Bus Reset Graceful,

                                      Power Cycle (Off - Soft Graceful)

Request Supported Power States      : On,

                                      Power Cycle (Off - Soft),

                                      Off - Soft,

                                      Master Bus Reset,

                                      Sleep -Deep,

                                      Hibernate (Off - Soft),

                                      Off - Soft Graceful,

                                      Master Bus Reset Graceful

Available Requested Power States    : Power Cycle (Off - Soft),

                                      Off - Soft,

                                      Master Bus Reset,

                                      Sleep -Deep,

                                      Hibernate (Off - Soft),

                                      Off - Soft Graceful,

                                      Master Bus Reset Graceful

 

Computer System Instance 1

Name                                : 2002:a8a:87b3:0:200:1aff:fe1c:4520

Element Name                        : Broadcom Management Controller

Primary Owner                       : N/A

Primary Owner Contact               : N/A

Enabled State                       : Enabled

Requested State                     : No Change

Current Power State                 : On

Requested Power State               : Off - Hard Graceful

PowerOn Time                        : N/A

Dedicated To                        : Management Controller

Supported Power Change capabilities : N/A

Supported Power States              : N/A

Request Supported Power States      : N/A

Available Requested Power States    : Power Cycle (Off - Soft),

                                      Off - Soft,

                                      Master Bus Reset,

                                      Sleep -Deep,

                                      Hibernate (Off - Soft),

                                      Off - Soft Graceful,

                                      Master Bus Reset Graceful

IPv4

Input

dashcli -h 192.168.0.12 -u admin -P adminpass enumerate computersystem

Output

Computer System Instance 0

Name                                : 12345678-1234-5678-90ab-cddeefaabbcc

Element Name                        : Computer System

Primary Owner                       :

Primary Owner Contact               :

Enabled State                       : Enabled

Requested State                     : No Change

Current Power State                 : On

Requested Power State               : Off - Hard Graceful

PowerOn Time                        : N/A

Dedicated To                        : Laptop

Supported Power Change capabilities : Power State Settable,

                                      Power Cycling Supported,

                                      HW Reset Supported,

                                      Graceful Shutdown Supported

Supported Power States              : Other,

                                      On,

                                      Sleep - Light,

                                      Sleep -Deep,

                                      Power Cycle (Off - Soft),

                                      Hibernate (Off - Soft),

                                     Off - Soft,

                                      Master Bus Reset,

                                      Off - Soft Graceful,

                                      Master Bus Reset Graceful,

                                      Power Cycle (Off - Soft Graceful)

Request Supported Power States      : On,

                                      Power Cycle (Off - Soft),

                                      Off - Soft,

                                      Master Bus Reset,

                                      Sleep -Deep,

                                      Hibernate (Off - Soft),

                                      Off - Soft Graceful,

                                      Master Bus Reset Graceful

Available Requested Power States    : Power Cycle (Off - Soft),

                                      Off - Soft,

                                      Master Bus Reset,

                                      Sleep -Deep,

                                      Hibernate (Off - Soft),

                                      Off - Soft Graceful,

                                      Master Bus Reset Graceful

 

Computer System Instance 1

Name                                : 2002:a8a:87b3:0:200:1aff:fe1c:4520

Element Name                        : Broadcom Management Controller

Primary Owner                       : N/A

Primary Owner Contact               : N/A

Enabled State                       : Enabled

Requested State                     : No Change

Current Power State                 : On

Requested Power State               : Off - Hard Graceful

PowerOn Time                        : N/A

Dedicated To                        : Management Controller

Supported Power Change capabilities : N/A

Supported Power States              : N/A

Request Supported Power States      : N/A

Available Requested Power States    : Power Cycle (Off - Soft),

                                      Off - Soft,

                                      Master Bus Reset,

                                      Sleep -Deep,

                                      Hibernate (Off - Soft),

                                      Off - Soft Graceful,

                                      Master Bus Reset Graceful

IPv6

Input

dashcli -h 2002:a8a:87b3:0:200:1aff:fe1c:4520 -u admin -P adminpass enumerate computersystem

Output

Computer System Instance 0

Name                                : 12345678-1234-5678-90ab-cddeefaabbcc

Element Name                        : Computer System

Primary Owner                       :

Primary Owner Contact               :

Enabled State                       : Enabled

Requested State                     : No Change

Current Power State                 : On

Requested Power State               : Off - Hard Graceful

PowerOn Time                        : N/A

Dedicated To                        : Laptop

Supported Power Change capabilities : Power State Settable,

                                      Power Cycling Supported,

                                      HW Reset Supported,

                                      Graceful Shutdown Supported

Supported Power States              : Other,

                                      On,

                                      Sleep - Light,

                                      Sleep -Deep,

                                      Power Cycle (Off - Soft),

                                      Hibernate (Off - Soft),

                                      Off - Soft,

                                      Master Bus Reset,

                                      Off - Soft Graceful,

                                      Master Bus Reset Graceful,

                                      Power Cycle (Off - Soft Graceful)

Request Supported Power States      : On,

                                      Power Cycle (Off - Soft),

                                      Off - Soft,

                                      Master Bus Reset,

                                      Sleep -Deep,

                                      Hibernate (Off - Soft),

                                      Off - Soft Graceful,

                                      Master Bus Reset Graceful

Available Requested Power States    : Power Cycle (Off - Soft),

                                      Off - Soft,

                                      Master Bus Reset,

                                      Sleep -Deep,

                                      Hibernate (Off - Soft),

                                      Off - Soft Graceful,

                                      Master Bus Reset Graceful

 

Computer System Instance 1

Name                                : 2002:a8a:87b3:0:200:1aff:fe1c:4520

Element Name                        : Broadcom Management Controller

Primary Owner                       : N/A

Primary Owner Contact               : N/A

Enabled State                       : Enabled

Requested State                     : No Change

Current Power State                 : On

Requested Power State               : Off - Hard Graceful

PowerOn Time                        : N/A

Dedicated To                        : Management Controller

Supported Power Change capabilities : N/A

Supported Power States              : N/A

Request Supported Power States      : N/A

Available Requested Power States    : Power Cycle (Off - Soft),

                                      Off - Soft,

                                      Master Bus Reset,

                                      Sleep -Deep,

                                      Hibernate (Off - Soft),

                                      Off - Soft Graceful,

                                      Master Bus Reset Graceful

 

Command 3: Power Status

HostName

Input

dashcli -h dash-system -u admin -P adminpass -t computersystem[0] power status

Output

Power state   : On

IPv4

Input

dashcli -h 192.168.0.12 -u admin -P adminpass -t computersystem[0] power status

Output

Power state   : On

IPv6

Input

dashcli -h 2002:a8a:87b3:0:200:1aff:fe1c:4520 -u admin -P adminpass -t computersystem[0] power status

Output

Power state   : On

 

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

more
4 0 1,469
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 627
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 693
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 843
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 1,499
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
7 0 1,564
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 2,239
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 5,277
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 2,191

WMI contains an event infrastructure that produces notifications about changes in WMI data and services. WMI event classes provide notification when specific events occur.

User can create a semisynchronous or asynchronous query to monitor changes to event logs, process creation, service status, computer availability or disk drive free space, and other entities or events.

In C++, IWbemServices::ExecNotificationQueryAsync() is used to get the callback in case of event creation/deletion/modification.

AMPS (DASHService) uses WMI event registration mechanism to get notified about changes in deployment classes of SCCM. We observed following issues in large scale enterprise infrastructure while using this mechanism :

  • WMI Event Registration failed. While registration for change in event for class SMS_ApplicationAssignment,  ExecNotificationQueryAsync() method failed with error code WBEM_E_QUOTA_VIOLATION.

pic.png

  • WMI Event notification not received even if WMI Event registration was successful.Notification query failed with error code WBEM_E_CALL_CANCELLED.

Picture2.png

AMD discussed with Microsoft about the same and filed following bugs for these issues:

https://connect.microsoft.com/ConfigurationManagervnext/feedback/details/3126741/wmi-event-registration-f...

https://connect.microsoft.com/ConfigurationManagervnext/feedback/details/3126744/wmi-event-notificat...

Workaround :We proposes to increase polling memory per user and polling memory total to solve this issue as workaround.

Please refer to below blog to change polling memory settings:

HOW TO CHANGE POLLING MEMORY IN WMI

more
1 1 5,702

  1. Go to Start–> run and type wbemtest.exe
  2. Click Connect on the Windows Management Instrumentation Tester
  3. In the namespace text box just enter "root" (without quotes)
    • 1.jpg
  4. Click on Query and run below query :
    • Select * from __ArbitratorConfiguration
    • 2.jpg
  5. Click on __ArbitratorConfiguration=@ and change following parameters :
    • PollingMemoryPerUser = 10000000
    • PollingMemoryTotal = 20000000
    • 3.jpg
  6. Click Save Property
  7. Click Save Object in the Object Editor window
  8. Close the other windows now and exit WMI Tester
  9. Restart the machine.

Change values of following parameters:

PollingMemoryPerUser = 10000000

PollingMemoryTotal = 20000000

more
0 0 5,536
Staff
Staff

A new release of AMD Management Console, AMC 2.5 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 2.5 release are:

  • Firmware Upgrade on the device  - this feature enables the user to upgrade or downgrade the firmware of a device.
  • Boot text image workflow - text based ISO images can be remotely deployed.
  • Support for Record Log profile - display platform logs of the DASH system.

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

Visit @DASH Home for downloading this software.

more
0 0 2,973
Staff
Staff

A new release of AMD Management Console, AMC 2.0 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 2.0 release are:

  • Demo mode, with the capability to work in private & closed networks.
  • Built-in web server to host ISO images to support USB redirection feature.
  • Support for Windows 8.1, Windows 10.
  • Various bug fixes.

Release note is attached, which provide more information on for this release and also the history of releases. AMC User guide is also attached, which provides information on all the features and their usage in AMC 2.0.

Visit @DASH Home for downloading this software.

more
0 0 1,542
Staff
Staff

A new release of AMD Management Plugin for SCCM, AMPS 3.0 is now available.

AMPS is a product that extends Microsoft System Center Configuration Manager 2012 to manage the desktop and mobile systems, out-of-band, using DASH standards. AMPS is essential part of enterprise IT management.

New features in 3.0 release are:

  • Firmware Upgrade on device and collection - Upgrade or downgrade the firmware of a device or on a collection.
  • Schedule DASH tasks on a collection - Power change and firmware upgrade operations.
  • DASH Scheduled Tasks tab - UI screen view all the scheduled DASH tasks.
  • "All AMPS Status Messages" Status Message Queries - Enable user to view all status messages related to AMPS.
  • New groupings of DASH systems:
    • All DASH Capable Systems - contains all DASH systems.
    • All DASH Managed Systems - contains all manageable DASH systems, that is, DASH systems that are provisioned with working credentials.
    • All DASH Unmanaged Systems - contains all unmanageable DASH Systems, that is, those DASH systems which do not have working credentials.
  • Reporting - Generate Configuration Manager style reports for DASH actions

Release notes is attached, which provide more information on for this release and also the history of releases. AMPS User guide is also attached, which provides information on all the features and their usage in AMPS 3.0.

Visit @DASH Home for downloading this software.

Related blogs:

Firmware Upgrade in AMPS 3.0- Detail steps on performing firmware upgrade

DASH User Action Report- Steps on generating report on DASH related actions performed by AMPS users

more
0 0 1,872

DASH User Action Report helps user to accumulate and organize all DASH activities along with details of user.

This report is enabled with AMPS 3.0 release.

pastedImage_0.png

SCCM users can generate this report by following below steps :

  • Expand Monitoring node and select overview and then Reporting.
  • Click on ‘Report Manager’ Link .

pastedImage_4.png

  • And click on “ConfigMgr_<siteCode>” Folder . Create a new Folder named “DASH Reports”.

pastedImage_14.png

  • Expand Reporting node and click on Report and select ‘Create Report’ and provide the name of report as ‘DASH User Action Report’ and path as ‘DASH Reports’ in Create Report Wizard. Select close on Create Report Wizard and Report builder will start where user can create the report query and its parameter.

pastedImage_25.png

  • Creating DataSets:
    • Create a new dataset. Click on ‘Add DataSet’.Rename the name as ‘DASHUserActionLogs’ and select “Use a dataset embedded in my report” and select the Datasource from dropdown menu. Select ‘Query Type’ as Text and place the below query in “Query” text box.

SELECT [ComputerName0],[Creation_Date0],[EventDetails0],[RecordID0],[Severity0],[SiteCode0],[Username0] FROM[CM_<site Code>].[dbo].[v_R_DASHUserActionLogs_2_0_0] WHERE ( (@Severity = 0) OR (@Severity = 1 AND Severity0 = 'Informational') OR (@Severity = 2 AND Severity0 = 'Warning') OR (@Severity = 3 AND Severity0 = 'Error') )AND Username0 = @Login AND ( (@DateRange = 0) OR (@DateRange = 1 AND Creation_Date0  >= DATEADD(dd,DATEDIFF(dd,0,GETDATE()),0)) OR (@DateRange = 2 AND Creation_Date0  >= DATEADD(dd,DATEDIFF(dd,0,GETDATE())-30,0)) OR (@DateRange = 3 AND Creation_Date0 >= DATEADD(dd,DATEDIFF(dd,0,GETDATE())-90,0)) OR (@DateRange = 4 AND Creation_Date0 >= DATEADD(dd,DATEDIFF(dd,0,GETDATE())-365,0)) )

pastedImage_30.png

    • Create a new dataset. Click on ‘Add DataSet’. Rename the name as ‘Users’ and select “Use a dataset embedded in my report” and select the Datasource from dropdown menu. Select ‘Query Type’ as Text and place the following query in “Query” text box.

SELECT DISTINCT[LogonName] FROM [CM_<siteCode>].[dbo].[v_Admins]

pastedImage_35.png

  • Creating Parameters:

@Login:

    • Expand the parameters and delete default parameters.
    • Click on “Add Parameters…”
    • Provide name as “Login” and prompt as “Users”
    • Click on Available values and select ‘Get values from query’. Select Dataset as Users (created in step 8) and ‘value field’ and ‘label field’ as “logonname”.

pastedImage_59.png

@Severity:

    • Click on “Add Parameters…”
    • Provide name as “Severity” and prompt as “Severity”
    • Click on Available values and select “Specific Values” and specify following pair of  values :

Label

Value

<All Values>

0

Informational

1

Warning

2

Error

3

pastedImage_64.png

@DateRange:

    • Click on “Add Parameters…”
    • Provide name as “DateRange” and prompt as “Date Range”
    • Click on Available values and select “Specific Values” and specify following pair of  values:

Label

Value

<All Values>

0

During Today

1

During Last 30 Days

2

During Last 90 Days

3

During Last 365 Days

4

pastedImage_65.png

  • Click on Table or Matrix option from center pane of Report Builder and select the dataset ‘DASHUserActionLogs’ created in step 5. Select all columns for final report and rename the header of selected columns as below:

[Creation_Date0] - > Date Time (UTC)

[Username0] -> Modified By

[Severity0] - > Severity

[EventDetails0] -> Event Details

[SiteCode0] -> Site Code

[ComputerName0] -> Resource Name

[RecordID0] -> Record Id.

Design header of the report and description like SCCM reports.

pastedImage_0.png

  • Save the report.
  • Expand DASH Category under Report Node and select ‘DASH User Action Report’ and run the report.

pastedImage_9.png

  • Report will prompt user to select user from “Users” dropdown, select severity from “Severity” drop down and select a date range from “Date Range” drop down.

Note : Replace <siteCode> to appropriate sitecode.

more
0 0 1,781
Staff
Staff

Firmware Upgrade feature is introduced in AMPS 3.0. It is based on DMTF's DASH standard specification, 'software update profile'. Firmware Upgrade feature enables the IT Administrator to perform installation and update of BIOS, firmware, drivers and related software on a managed system.  Please check with your OEM support, to find the software modules enabled for firmware upgrade. This blog demonstrates Firmware Upgrade for Broadcom's Gigabit Ethernet client controller, BCM5762.

Here is the overview of using this feature:

Host firmware versions on web server

Setup a web-server and copy the firmware software modules.  These firmware must be accessible at the manged system. Figure 1 illustrates the firmware modules for BCM5762.

1.png

Figure 1, Web server hosting firmware

Save URLs in AMPS firmware list

In the Configuration Manager console, navigate to Assets and Compliance\Overview\Devices\All DASH Managed Systems. Select any DASH system and in DASH tab, click 'Firmware Upgrade'.

2.PNG

Figure 2, Firmware Upgrade icon in Configuration Manager console

Firmware Upgrade window opens with empty URL list if the URLs were not saved before. Click on '+' to add new URLs. After adding all URLs, save them using 'Save' button.

3.PNG

Figure 3, Adding URLs

After saving, the URLs will be listed as shown in Figure 4.

4.PNG

Figure 4, URL List

Start Firmware Upgrade

In the Firmware Upgrade window, select software module. The current version of that software module is displayed below it. In this example, 'Management Controller Firmware' is selected and version of it is 3.04.01.

5.PNG

Figure 5, Firmware Selection

In this example, we will upgrade from 3.04 to 3.05. Version 3.05 is selected in the URL list and 'Apply' button is clicked to start Firmware Upgrade process. After few minutes, Firmware Upgrade will be completed and success message is displayed, as shown in Figure 6.

6.PNG

Figure 6, Firmware Upgrade Success

Verify

To check whether the upgrade was successful, you can query the current version of the  software module by opening 'Firmware Upgrade' window.  In Figure 7, the version is '3.05.03', which means Firmware Upgrade was successful from 3.04 to 3.05.

7.PNG

Figure 7, Software Module Version

In case of management controller firmware, you also check the version in 'Discovery' window.

8.PNG

Figure 8, Management Controller Firmware version

Collection

Firmware Upgrade can be done on collection. Open 'Firmware Upgrade' on a collection, select the new URL and apply. You can also schedule the upgrade at a later time.

9.PNG

Figure 9, Firmware Upgrade on Collection

References:

  1. DASH Home: http://developer.amd.com/tools-and-sdks/cpu-development/tools-for-dmtf-dash/
  2. Software Update Profile: Software Update Profile | DMTF

more
0 0 2,045
Staff
Staff

A new release of AMD Management Plugin for SCCM, AMPS 2.5 is now available.

AMPS is a product that extends Microsoft System Center Configuration Manager 2012 to manage the desktop and mobile systems, out-of-band, using DASH standards. AMPS is essential part of enterprise IT management.

New features in 2.5 release are:

  • Boot text image feature – text based ISO images can be remotely deployed. Multiple DASH tasks are combined into a workflow to accomplish the deployment task.
  • Performance enhancements to handle large number of devices in a collection - DASH tasks can be run on maximum supported clients by the Configuration Manager 2012 R2.

Check the attached release notes for more information and visit DASH Home for downloading this software.

Important links:

more
0 0 1,810
Staff
Staff

A new release of AMD Management Plugin for SCCM, AMPS 2.3 is now available.

AMPS is a product that extends Microsoft System Center Configuration Manager 2012 to manage the desktop and mobile systems, out-of-band, using DASH standards. AMPS is essential part of enterprise IT management.

New features in 2.3 release are:

  • DMTF DASH 1.2 compliance
    • Record Log
    • Service Processor
  • Role based administration supported for DASH operations
  • Enhancements to power operations on collections
  • Dash wake-up support for software updates & deployments

Check the attached release notes for more information and visit DASH Home for downloading this software.

Important links:

more
0 0 2,123
Staff
Staff

This post will illustrate how DASH option can be enabled on fresh HP 6305 system and later provisioned for access from management consoles.

HP 6305 comes with Broadcom 5761 ethernet controller. DASH management option must be enabled in BIOS and required software must be installed on Windows OS. Let us start with changes in BIOS.

BIOS Changes

DASH Management option must be enabled in the BIOS. To confirm, goto BIOS\Advanced, select and enter Management Operations

100-BIOS-DASH_Option.jpg

In the Management Operations, these options must be enabled

  • DASH Support
  • DASH Console Redirection.

Press F10 to save the changes and exit BIOS.

200-BIOS-DASH-Enable.jpg

Note: You could request the OEM (HP in this case) to have these options enabled by default in factory BIOS.


Microsoft Windows Changes

This post illustrates the changes to be made on Windows OS. For other OS, check either HP or Broadcom documentation.

(1) Network Driver

Boot to Windows OS. The recommended network driver version is 16.6.0.4b or above. To confirm the driver version, goto 'Control Panel\All Control Panel Items\System', open 'Device Manager', expand 'Network adapters', right click on 'Broadcom NetXTreme Gigabit Ethernet Plus' adapter and select 'Properties'. In the driver tab, verify the 'Driver Version'.

300-Broadcom-Driver-version.jpg

In case the driver version is old, to get the latest driver, download Broadcom's 'NetXtreme Software Kit' version 16.6.4.1 or highrer. Extract the archive, go to the folder 'B57HPCD-DT-v16.6.4.1/MgmtApps/x64' and run,

setup /s /v /qn

This option will install the required driver and the software required for DASH management.

Note: Broadcom NetXtreme Software Kit can be obtained from either HP support or Broadcom support site.

500-NetXtreme-Package-Version.jpg

(2) Broadcom Management Agent

Open 'Control Panel\All Control Panel Items\Administrative Tools\Services' windows and ensure status of 'Broadcom Management Agent' is 'Running'. If it is not running, check if 'Broadcom NetXtreme Software Kit' version is right and is correctly installed.

400-Broadcom-Agent-Service.jpg

(3) Broadcom WMI namespaces

This is additional verification step. Goto Start\Run, enter 'wbemtest' and click OK. In the window, Connect to  'root\BrcmBnxNs' namespace and verify if connect is successful. If connect fails, check if 'Broadcom NetXtreme Software Kit' version is right and is correctly installed.

600-WMI-Test.jpg

Note: You could add the right version of Broadcom NetXtreme Software Kit to your organization's OS image.


Once these settings are in place, HP 6305 can be provisioned either locally or remotely using DASHConfig tool. Checkout the detailed usage of DASHConfig here - How to use AMD DASHConfig tool to provision DASH capable targets

(4) Quick steps using DASHConfig

DASHConfig is packaged with AMPS (AMD Management Plugin for SCCM), AMC (AMD Management Console) and DASHCli. These tools can downloaded from http://www.amd.com/DASH

1) In the DASHConfig folder, edit the 'DASHConfigExample.xml' file. Fill in digest credentials or active directory settings and save the file.

2) On the HP 6305 DASH system, from the Command-Prompt, go to the DASHConfig folder and run the command,  "DASHConfig.exe –xf:DASHConfigExample.xml -lfSmiley Very HappyASHProvision.log"

HP 6305 will be provisioned. Now the system can be discovered and managed by any Management Console which supports DASH.

Resources:

more
0 0 4,100