Summary

JumpCloud lets you run commands across any number of systems (Windows, Mac OS X or Linux) or tags in parallel. Once you have a good understanding as an Administrator of Using the Commands Tab, you may determine further ways that you can orchestrate your IT activities using JumpCloud.

This article will help to provide you requirements, examples as well as configuration information for installing third-party applications to your JumpCloud managed systems using the Commands Tab.

Prerequisites

Before getting started with installing any applications on Windows or Mac OS X using the Commands tab, there are several considerations that will need to be evaluated. You will need to refer to your software vendor’s documentation or support resources to ensure that the package will be supported with JumpCloud per the prerequisites listed:

Jump Desktop is the best remote desktop client on the Mac. With features built from the ground up to increase productivity, Jump is a must-have. The unique keyboard remapping feature lets you use Mac shortcuts on Windows and achieve maximum productivity during long remote desktop sessions. From the JumpCloud Administrative Console, click on the Commands tab on the left-hand navigation Click the + button at the top-left to create a new command At the top of the Execute Command window choose either Linux, Windows or Mac depending on your target system (s). Open the Control Panel, click on Startup Disk, and change the setting; this item will only appear if the Boot Camp drivers are installed. Alternatively, restart the computer with the X or Option keys held down; in the second case, select the Mac OS X system, push the button with the straight arrow, and change the startup disk from System Preferences afterwards. Jump Desktop is a powerful remote desktop application that lets you control your computer from your phone or tablet. Compatible with both RDP and VNC, Jump Desktop is secure, reliable and very easy to set up. A streamlined user interface gives you the best possible remote desktop experience on any of your mobile or tablet devices.

Command-line Installation Support

While this requirement may seem like an unspoken one, in order to successfully install the application to a JumpCloud-managed system it will need to support execution from the command-line. This is important being that not all packages support non-UI installations.

Windows

In many cases EXE as well as MSI installation packages (Refer to Windows Installer wikipedia article for more information) will be supported. MSI packages in particular are provided for system administrators who would need to deploy the software to several terminals over a network connection. There shouldn’t be any major differences when comparing an MSI and EXE from a functionality standpoint, however there may be additional options available for MSI packages such as performing “silent” installs or having additional pre-configuration options. Because of this, MSI packages may in some cases be more compatible with the JumpCloud Commands tab. Please refer to your software vendor’s documentation and support for further information on the best options and supported methods.

Mac OS X

As with Windows, application vendors will distribute different application package types when working with a Mac OS X application. This may include DMG files, PKG files, compressed archives (.zip, .tgz, etc.) or even flat application files. A DMG file is a disk image, which will require the image to be mounted to the system in order to view it’s contents. Because of this, you may find that application deployment will be more preferred using either PKG files, compressed archives or application files but your vendor documentation and support can provide you direct advisement.

Unattended or Silent Installation

The Commands tab works in such a way that commands are sent to the system for execution and a pass/fail results along with any command result details are displayed within JumpCloud. Because the Commands tab does not present the administrator with an interactive session when performing execution, it is required that all application installations have “silent” or “unattended” installation options. The functionality and terminology can differ from software vendor to software vendor so this may require discretion on your part. By definition a “silent” install should be one that does not display any indication of progress, while an unattended installation is once which does not require user interaction. Explicitly, JumpCloud requires an “unattended” installation which does not require user interaction, but note that some vendors will in fact refer to this as “silent”.

As an example, our very own (Windows) Command Line Installation KB article is a great example that outlines command-line install to a Windows system where a unattended/silent option is available. There are three flags available for our EXE to aid in unattended installations in the form of /SILENT,/VERYSILENT and/SUPPRESSMSGBOXES:

JumpCloudInstaller.exe -k CONNECT_KEY /VERYSILENT /NORESTART

Setup & Execution

Using Upload File with the Commands Tab

You can upload one or more files to be pushed to the server prior to executing the command, including an installation package. The file push occurs immediately before the command is executed, so you can update the files anytime, and know that the next time your command runs, it will have the latest update. You can include any data you like, such as a tarball, that your script can untar and utilize for any purpose.

Note that the Upload File functionality within JumpCloud only supports files of 1MB or smaller size. If your installation package is larger than this, you may want to refer to the next section for downloading a file from a web-hosted source or placing in a centralized network destination external to JumpCloud.

  1. From the JumpCloud Administrative Console, click on the Commands tab on the left-hand navigation
  2. Click the + button at the top-left to create a new command
  3. At the top of the Execute Command window choose either Linux, Windows orMac depending on your target system(s)
  4. Before populating your installation command into the main pane, click Upload File under the Files section to attach the installation package
  5. Once selected, take note of the File Destination field and it’s default value. Feel free to specify a different local directory on the target machine as needed
  6. Populate your installation command, and take note that you will need to specify the full package path was was specified in Step 5
  7. Choose the target Systems and or Tags that you would like to execute to from the right-hand side
  8. Choose to either Save & Run Now, or click Save for later usage

Downloading Installation Packages

While planning your deployment strategy, you may find that you want to look at other alternatives than the native Upload File functionality provided. This could be due to considerations ranging from the 1MB file limitation that is discussed above, to trying to have a more streamlined method of package acquisition that allows for management external to JumpCloud.

One option that is available to you is to use Windows PowerShell or Bash Shell (Mac OS X) to download a file from a web server for subsequent install.

Windows PowerShell

The following PowerShell command will download a file from a web server to the local machine, and allow you to specify the directory it lives:

(New-Object System.Net.WebClient).DownloadFile('<FILE_DOWNLOAD_WEB_PATH>', '<LOCAL_FILE_DOWNLOAD_PATH>')

Below is an example of the command which is downloading the Windows JumpCloud Agent, and placing the file into the C:WindowsTemp directory. This is purely an example being that the JumpCloud agent must be installed prior to the ability to send commands to the system:

(New-Object System.Net.WebClient).DownloadFile(“https://s3.amazonaws.com/jumpcloud-windows-agent/production/JumpCloudInstaller.exe”, “$env:TEMP/JumpCloudInstaller.exe”)

Mac OS X

The following Bash Shell command will download a file from a web server to the local machine, and allow you to specify the directory it lives:

curl -o <LOCAL_FILE_DOWNLOAD_PATH '<FILE_DOWNLOAD_WEB_PATH>'

Jump and run (greenduckstudio) mac os x

Below is an example of the command which is downloading the Mac OS X JumpCloud Agent, and placing the file into the /tmp/ directory. This is purely an example being that the JumpCloud agent must be installed prior to the ability to send commands to the system:

curl -o /tmp/jumpcloud-agent.pkg 'https://s3.amazonaws.com/jumpcloud-windows-agent/production/jumpcloud-agent.pkg'

Executing the Command

At this point you should now have a good understanding on what is required prior to command execution for an application installation. Once you have confirmed that your package supports command-line installation, allows for unattended options and have determined how you will upload/download the installation to the target system you are ready for install.

Jump And Run (greenduckstudio) Mac Os X

For more information on the options available with Commands, please refer to Using the Commands Tab.

If you require have any questions or concerns, please contact support@jumpcloud.comfor further assistance.

Jump And Run (greenduckstudio) Mac Os Catalina

(Redirected from Mac 68K emulator)

The Mac 68k emulator[1] is a softwareemulator built into all versions of the classic Mac OS for PowerPC. This emulator enabled running applications and system code that were originally written for the 680x0-based Macintosh models. With a few exceptions, notably Connectix's RAM Doubler, the emulator ran all software with no noticeable impact other than lower performance relative to the same program when compiled for PowerPC.

Origins[edit]

The first version was written by Gary Davidian, who had originally created it for use on the Motorola 88000 CPU, used in Apple's abortive first attempt at a RISC target platform.[2][3] A later version, using dynamic recompilation, was developed by Eric Traut, who later worked on successful emulation projects at Connectix such as Virtual Game Station and Virtual PC. Prior to Traut's arrival there, Connectix had released Speed Doubler, which included an even faster PowerPC 68k emulator.

Jump And Run (greenduckstudio) Mac Os Update

Implementation[edit]

All versions of this emulator emulated the 'user' subset of the 68EC040instruction set with a 68020/68030 exception stack frame. Apple developer documents indicate that the emulator provided an operating environment most closely resembling that of the Macintosh Centris 610, a system based on the Motorola 68LC040 microprocessor.[4] Early versions emulated it by decoding each instruction and immediately carrying out a series of equivalent PowerPC instructions. For the PCIPowerMacs, the dynamic recompilation emulator was used to boost performance. Dynamic recompilation works by 'recompiling' common sections of the code into faster, PowerPC-native, sequences that were locally cached. The emulator could recognise the same sequence of 680x0 code and run the previously-cached PowerPC code to avoid doing the translation again. This emulator was theoretically capable of emulating 680x0 code faster than any real 680x0 was capable of running it. The 68LC040 had no floating point instructions, making this feat slightly simpler but no less impressive.

One reason that this emulation was so successful is that many of the APIs for the Mac OS were originally implemented as traps on the 680x0 processor; therefore, calling an API actually was recognised by the 680x0 as the equivalent of an error condition, which would cause it to handle that error through one of its hardware vectors. In turn, this vector would look up and run the operating system routine from ROM or RAM. In the emulator, such traps could be replaced by native PowerPC code, so the only code being emulated was the application itself, and any system API it called could be accelerated with native PowerPC code. This also allowed Apple time to port the OS to the PowerPC. At first only time-critical aspects were rewritten in native code, leaving much of the OS emulated. Gradually most of the OS was rewritten to be native, so the OS got faster over time.

For the programmer, the transition to the PowerPC was made fairly painless, because the emulator was started and stopped automatically. This was achieved using a new type of pointer called a Universal Procedure Pointer (UPP). For 68k code, this pointer appeared to be an ordinary pointer to code and could be used as such. However, it actually led to a data structure which contained a special trap instruction and flags indicating the instruction set architecture (ISA) of the called code. From PowerPC code, this UPP could be passed to the CallUniversalProc( ) function to call it. The 68k emulator then dealt with details such as presenting passed parameters in the right order for the ISA in question, as well as starting and stopping the emulator as required. The compilers for Mac OS created such UPPs automatically when the proper macros were used, and the PowerPC system libraries contained native stubs to transparently call through to native or still-68k functions as needed. This meant that dealing with the dual architecture required very little work for the programmer, and just like the OS, applications themselves could mix and match 680x0 and PowerPC code fairly easily.

Current status[edit]

Because it was built into all PowerPC versions of the classic Mac OS, the emulator was also part of the Classic environment in Mac OS X. PowerPC Macintosh emulators such as SheepShaver therefore use the emulator as well when running the classic Mac OS. Native Mac OS X outside of Classic never used the emulator.

See also[edit]

  • Alpha Microsystems for a similar architecture to run 68k code on x86
  • Rosetta, a similar feature in Mac OS X that translates PowerPC instructions to x86 instructions, and later, x86 instructions to ARM instructions

References[edit]

  1. ^http://support.apple.com/kb/TA25871
  2. ^'The PowerPC Triumph'. Retrieved 1 July 2011.CS1 maint: discouraged parameter (link)
  3. ^'Power Computing: Fighting Back for the Mac or Stealing Apple's Customers?'. Retrieved 1 July 2011.CS1 maint: discouraged parameter (link)
  4. ^'The 68LC040 Emulator (IM: PS)'. Retrieved 1 July 2011.CS1 maint: discouraged parameter (link)
Retrieved from 'https://en.wikipedia.org/w/index.php?title=Mac_68k_emulator&oldid=1019719935'