Reasonably Random Rants and Raves

Blog

  • How to: Configuring macOS to do web development: Part 1 – Apache

    A good chunk of what we need do web development exists in macOS 12.1 (Monterey) without having to resort to add-ons like the XAMPP stack. I have enough of my students asking me how to do this that I thought I would consolidate my notes and put them up on the web so I can just point them at that reference. This is going to pull from multiple sources and I’ll try to acknowledge every one that I can. Let me know if I missed one.

    There are some things you will need to add.  Recent versions of macOS no longer include PHP as part of the operating system.  That’s actually a good thing as the tendency has been for the version included has tended to lag behind the current tip of development.  Here’s where you find yourself using a package manager like Homebrew.

    First step: Configuring Apache

    The OS includes the Apache web server.  It’s buried pretty deep into the system bits so you are going to having to apply some important skills:

    • Understanding of working with the Terminal.app to run command-line programs to update configuration files and manage the web sever

      • ,

    • Know some of the internals of the Apache web server,
    • And know how to open and save files in text editor like vi or nano.

    This information is spread over the Internet but the bulk of the material is taken from the Apple tech support discussion forum at https://discussions.apple.com/docs/DOC-250004361

    Start by editing the web server configuration file located at /etc/apache2/httpd.conf. Note that this requires admin permissions, so you will need to use sudo:

    
sudo vi /etc/apache2/httpd.conf

    Look for the line in the file that enables the “Sites” folder for individual users (this is equivalent for macOS as public_html is for Linux). In recent versions of macOS, this is at line 184 in the file. Uncomment that line by removing the leading “#” comment indicator. It needs to read as follows:

    
Include /private/etc/apache2/extra/httpd-userdir.conf

    Save and exit the editor.
     

    This change tells the web server to look for an include configuration file that will define user folders in the web server. Edit that file:

    
sudo vi /etc/apaches2/extra/httpd-userdir.conf

    Uncomment line 16 of that file so that it reads:

    
Include /private/etc/apache2/users/*.conf

    Now you need to tell the web server that about your user folders. First step, look in the Users and Group preferences pane to get your short user name. Right click on your user name in the pref pane and select “Advanced Options”. The short user name can be found in the “Account Name” field. For discussion purposes, we’ll use my short name of “alewis”. Replace this with your own when you do this,.

    Now let’s use your tex editor to create a configuration file for user folders:

    
sudo vi /etc/apache2/users/alewis.conf

    Add the following content:

    
<Directory “/Users//Sites/”>
 AddLanguage en .en
 Options Indexes MultiViews FollowSymLinks ExecCGI
 AllowOverride None
 Require host localhost
</Directory>

    You will need to add additional configuration items to this file if, for example, you want to enable PHP.

    Then create the Sites folder in your home folder:

    
mkdir ~/Sites
echo “<html><body><h1> My site works</h1></body></html>” > ~/Sites/index.html.en

    This creates the Sites folder and adds a minimal working example in the folder that we can test against shortly.

     

    Now we have to do some shell voodoo. Apple has tightened up the security in macOS 12 to, by default, not allow other users access to a user’s folders,. The macOS installation of Apache is configured to run in a special hidden user account named “_www”. You need to setup an Access Control List (acl) that lets the web server have access to your folder:

    
chmod +a “_www allow execute” ~/Sites
 

    And now we see if things work. With Apache, one should always use the web servers configtest command to make certain things are configured in a clean manner:

    
apachectl configtest
 

    So… what’s apachectl? That’s a command line tool that one uses to control the web server (which is an Apache thing, and so works on any of the UNIX-based operating systems). If the config test returns ‘Syntax OK’, then you are ready to rock the web.

    Now for macOS command-line magic… you need to tell macOS to start Apache at system startup:

    
sudo launchctl load -w /System/Library/LaunchDaemons org.apache.httpd.plist

    If you want to get things running in the meantime, do a:

    
sudo apachectl graceful
 

    At this point, navigate to http://localhost and http://localhost/~<your short user name> and see if you get the expected responses from the web server.

     
    Reference: https://discussions.apple.com/docs/DOC-250004361

    Next up: Getting PHP to work using Homebrew.

  • By request, a recipe for Baked Kofta With Potatoes

    A number of people on social media asked for this recipe after I posted pictures of it when I recently made it for supper.   If memory serves me right (yep, that was an original Iron Chef reference),  I got the recipe from an episode of Milk Street TV

    INGREDIENTS 

    1 pound Yukon Gold potatoes, not peeled, sliced into ¼-inch rounds
    2 tablespoons plus ¼ cup extra-virgin olive oil, divided
    Kosher salt and ground black pepper
    1 pound ground lamb or 80 percent lean ground beef
    1 medium yellow onion, halved and grated on the large holes of a box grater
    1/2 cup finely chopped fresh flat-leaf parsley
    1/2 teaspoon ground allspice
    1/2 teaspoon ground cinnamon
    14 ½ ounce can crushed tomatoes
    2 medium garlic cloves, minced
    1 pound plum tomatoes, cored and sliced into ¼-inch rounds
    1 small green bell pepper or Anaheim chili, stemmed, seeded and sliced into thin rings

    DIRECTIONS

    Heat the oven to 450°F with a rack in the middle position. On a rimmed baking sheet, toss the potatoes with 1 tablespoon of oil and ¼ teaspoon salt. Distribute in a single layer and roast without stirring just until a skewer inserted into the potatoes meets no resistance, 10 to 13 minutes. Remove from the oven and set aside to cool slightly. Leave the oven on.

    While the potatoes cook, line a second baking sheet with kitchen parchment. In a medium bowl, combine the lamb, onion, parsley, allspice, cinnamon, ¾ teaspoon salt and ¼ teaspoon pepper. Using your hands, mix gently until just combined; do not overmix. Divide the mixture into about 20 golf ball-size portions (1½ to 1¾ inches in diameter) and place on the prepared baking sheet. Flatten each ball into a patty about 2½ inches wide and ¼ inch thick (it’s fine the patties are not perfectly round); set aside until ready to assemble.

    In a 9-by-13-inch baking dish, combine the crushed tomatoes, garlic, the ¼ cup oil, ½ teaspoon salt and ¼ teaspoon pepper. Stir well, then distribute in an even layer. Shingle the potatoes, tomato slices, green pepper rings and meat patties in 3 or 4 rows down the length of the baking dish, alternating the ingredients. Drizzle with the remaining 1 tablespoon oil and sprinkle with pepper.

    Bake, uncovered, until the kafta and potatoes are browned and the juices are bubbling, 25 to 35 minutes. Cool for about 10 minutes before serving.

  • Command Line Knowledge for macOS: “Burn” ISO to SD Card

    I have to live the “multi-operating system” life style. So. There are times where you find yourself dealing with install media that’s ISO image. And often enough, it’s my MBP that’s the only thing I’ve got connected to the network at the time.

    All right, I have to keep looking up the instructions for “burning” an ISO to removable storage so often that I just figure post them here and see if Google (or preferably, Duck Duck Go) will find them for me the next time I have to do this.

    The steps:

    1. Convert from iso to disk image format using hdiutil: 
      
hdituil convert –format UDRW -o ~/path/to/dest.img" ~/path/to/target.iso

       
    2. Use diskutil to find out where the removable device has been mounted into the file system. 
      diskutil list
    3. Unmount the device using diskutil. 
      diskutil unmountDIsk /dev/diskN
       
    4. Use dd to copy the disk image to the raw device. Note you’ll need admin access for this and do remember that dd is destructutive. THINK before hitting that enter key: 
      sudo dd if=~/path/to/dest.img of=/dev/rdiskN bs=1m
    5. Now eject the removable device: 
      diskutil eject /dev/diskN

    Hopefully useful… Selah.

  • Command Line Knowledge for macOS: software update

    One of the leading reasons to dive into the command-line tools in macOS is automation.   Writing scripts that link with the Shortcuts stuff adapted from iOS means you can automate some things.

    For instance, there is a command-line tool that you can use to run software updates: software update.

    Consider: 

    
softwareupdate -l

    This gets you a list of available software just like what happens in System Preferences when you launch the Software Update preference pane. In both cases, the utilities are talking the softwareupdate daemon in the operating system.

    Next up, getting stuff installed:

    
softwareupdate -I NAME
softwareupdate --install name

    You replace NAME with one of the items from the list you asked for in the first step. Be careful there as macOS is very sensitive about names and format of names. You should quote the names and watch out for cases where the name has trailing spaces.

    The “-d” option will just download an update while including the “-a” option will install all available updates. One of the useful options for this command-line tool is “–install-rosetta”. This option tells macOS on Apple silicon Macs to install the Rosetta 2 hypervisor/emulator for Intel macOS applications. Include the –agree-to-license” option to agree to the software license agreement without user interaction.

    Selah.

  • Command Line Knowledge for macOS: diskutil

    I have found over the years that the Disk Utility app in macOS has become less and less useful to me over the years.   My guess has been the dev teams at Apple have trying to cut back on the ability of less informed to do unpleasant things to themselves using the tool.

    But with a little effort we find the macOS diskutil utility. This is also where we begin to see some the FreeBSD heritage in macOS as this is follows the FreeBSD “noun verb” UX for commands where you enter diskutil followed by a number of verbs that do the work.

    Let’s start with the list verb. Issuing the command:

    diskutil list

    Gets you a listing of currently mounted disks, partitions, and mount points. This is fun as you get a lot more detail about the internals of how APFS is blatting stuff through your disk. For instance, on my machine I have /dev/disk0 as the physical disk with an APFS container disk in a partition. That logic disk is mounted as /dev/disk3 with the multiple volumes in the container. This is far more detailed information than what you get from the user interface.

    The info verb gets you the details for a specific disk. Again, lots of detail but good for troubleshooting. The umount and umountDisk verbs are for un-mounting partitions and disks out of a file system while mount goes the other way. It’s important to understand that the eject verb is for removable devices and is the same action as ejecting a drive in Finder.

    All of the formatting and partition things you do in the GUI have corresponding verbs in the command-line tool. Do be careful as with great power comes with great responsibility. Think twice and then again before hitting that enter key.

    The jobby-job thing that I do to pay the bills requires me to do a bunch of system administration things. So, I’m often needing to “burn” a Linux installer to a USB key. Here we can use a combination of the diskutil and hdiutil command-line tools to automate that process.

    First, use the list verb to find the mount point for the USB device that’s your target device:


    diskutil list

    Now we can write a Bash script that will do the heavy lifting for us:

    
ISONAME=$1
DESTDISK=$2
TMPIMG=“~/tmp/copytarget.img”
hdiutil convert UDRW -o $TMPIMG $DESTDISK
diskutil unmountDisk /dev/$DESTDISK
dd if=$TMPIMG of=/dev/r$(DESTDISK) bs=1m
diskutil eject $DESTDISK
rm $TMPIMG

    So, our little script takes two parameters: the filename of the Linux ISO and the base name of the disk mount point. This script first uses hdiutil to convert the ISO into a macOS disk image. I keep a temp folder in my home folder for these sort of things. We then unmount the external device and use the classic UNIX dd command to do a byte-by-byte copy to raw version of the mount point. After doing this, you need to eject the device.

    And that’s a quick summary of diskutil.

    Selah.

  • Command line knowledge for macOS

    Non-developer types (you know, you “normies” out there) tend to want to do everything using the mouse rather than the keyboard. Really true for people using macOS. Makes me hurt when I see it as there are many things easier to do with the command line than with multiple mouse clicks.

    This isn’t going to be series talking about how to do stuff in Bash or zsh using the Terminal application. Lots of introductions out on the Intertubes about Shell programming and how one can use it to automate for fun and profit. This series is going to point out things that about using the command line in macOS that you don’t often hear about.

    Like what things? Many of the tools you use to run macOS have lesser known command line interfaces. Classic examples are apps like Disk Utility and Software Update. Both have command line interfaces that allow you to do stuff in single commands that take multiple clicks in the GUI. That’s what we’re going to examine in this series of posts.

    But there are some things available to you in the Terminal app and with Bash and/or zsh that you can use to make your life easier. Drag and drop is supported by Terminal… dragging a folder icon from Finder to the Terminal’s Dock icon opens a new window in the app and changes the current working folder to that that folder. Dragging files onto a Terminal window inserts their paths separated by spaces.

    A really useful thing is the open command. Issuing the command by itself in a shell will open the current working folder in a Finder window. You can specify a file name as an option:

    open ~/Library/Preferences
open ../..
open /etc

    Provides a quick way to get to hidden folders when you need to do something “admin”-like on your machine.

    You can open a specific file, which will use the current association for that file type to open the file, or use the -a option to specify the app to use to open the file. You have the -e or -t options to open a file using TextEdit or your favorite editor.

    Really useful is the -f option which allows you to pipe text into the open command. This allows you to use open within shell pipelines, up to and including getting output from a command into a text editor.

    Lots of things that you can do here and Terminal’s linkages into Finder and the open command give you way to link the things you do in the Terminal with the windowing system and vice-versa. So go grab a good tutorial in the use of zsh and enjoy!

    Selah.

  • It’s time to fire this guy back up

    Time to start things back up with my blog. I’ve let my web presence and blog languish a bit. Been putting too much focus on the social media things, truth be told.

    So it’s time to start putting up some new content. Like what? Been having to do some work on NLP and am working on a couple of posts on setting up an environment for doing that. I’ve also been having to do some sysadmin things on Macs and have found lots of less known command-line tools that I think my notes would be helpful to someone else.

  • A Useful Little VirtualBox Trick

    I’m teaching a Security Fundamentals course this semester and we’ve gotten to the point where we’re talking network security. In particular, we’re talking about using Wireshark to monitor and trace networks. I’ve found an interesting and useful little feature in VirtualBox.

    Virtual Network Cards

    VirtualBox, like most virtual machine managers, emulates network interface cards. So… how can I go about tracing these interfaces? The neat feature is that we can use the command-line management tool to capture all traffic on one of these virtual interfaces.

    Step 1: Turning on network capture

    Let’s trace traffic on the first virtual network interface:

    VBboxManage modifyvm "ubuntu" -nictrace on -nictracefile1 vmtracefile.pcap"

    This turns on the tracing of the first network interface in the “ubuntu” virtual machine. At this point you start the VM and duplicate whatever situation you need to test.

    Step 2: Turning off network capture

    When you’re done, you turn off the tracing with the command:

    VBoxMange modifyvm "ubuntu" -nictrace off

    A few caveats

    Don’t forget to turn off tracing as it’s both a security risk and the trace files can get very large. The VirtualBox documentation suggests the use of snapshots in combination with this feature to keep track of what you’re doing and minimize the window in which tracing is left on.

    Lessons learned

    Look closely at the underlying command-line interfaces for your virtual machine manager. One can find many very interesting features and tools hiding underneath the covers of the GUI.

    Selah.

  • Something simple

    Late spring means strawberries in North Alabama. Strawberries require pound cake. They just do.

    Good thing is that pound cake is one of simplest things you can bake. I’ve seen a number of recipes similar to this one spread throughout the Internet. More importantly to me is that this is very similar to recipe that my Mom uses for her pound cake.

    Basic Pound Cake

    Ingredients


    
1 1/3 c. butter, softened
    
2 1/2 c. sugar
    
6 eggs
    
3 c. all-purpose flour
    
1/2 c. buttermilk
    
1 teaspoon vanilla extract

    Instructions

    Preheat oven to 325dF. Beat butter until creamy. Add sugar in portions, beating at medium until fluffy. Add eggs, 1 at a time, making certain that each egg is blended adding the next egg.

    Add flour and buttermilk, beginning and ending with flour, beating at low speed until just blended. Stir in vanilla.

    Pour into greased and floured tube pan. Bake for between 65 to 70 minutes. Test for doneness if toothpick comes out clean. Cool in pan for 10 to 15 minutes, remove from pan, and allow to cool for at least another 20 minutes before serving.

    Selah.

  • Spring. Something simple for the season

    Today’s Easter Sunday. Got me thinking back to my time working in Israel and remembered a chicken dish that I really liked at one of the restaurants in Tel Aviv. After some digging in my Israeli and Greek cookbooks, I’ve pulled together something I think might be close:

    Braised Chicken with Lemon, Orange, Garlic, and Olives

    4 bone-in, skin-on chicken thighs
Salt and black pepper, to taste
3 Tbs. olive oil
6 garlic closes
2 yellow onions, thinly sliced
1 lemon, juiced, zested, peeled, and thinly sliced
Juice from 2 tangerines
1 tbs. dried basil
1 tsb. oregano
1 cup mixed, pitted olives

    Preheat oven to 375dF. Dry chicken and season with salt and pepper. In Dutch oven, heat olive oil over medium heat. Sear chicken until golden brown. Add garlic and zest of lemon. Cook until fragrant. Remove chicken and garlic from the pan and reserve.

    Add onions to pan and cook until wilted. Add lemon slices and cook for 2-3 minutes. Add lemon and tangerine juice, basil, and oregano and deglaze pan. Add lemon slices and olives and stir to combine. Nestle thighs skin skin side up onto onion mixture. Cover and bake for 40 to 60 minutes.

    Selah.