Over the years, I've been the online leader for 2 different groups at Meetup.com. It's a great place to organize calendars of activity, and it's free to use for attendees. They charge meeting organizers for the service, but it's way too expensive for what it costs Meetup to provide that service. They charged US$150/year for each group, the last I knew a year ago. That's too rich for my blood, so I eventually stopped paying both of them.

Twin Cities Powershell Automation User Group is looking for a new leader, but it may not get one. It'd be a shame to lose it. I created that group back in 2014 October 14. (I got the date from the earliest copy at the wayback machine.) The powershell group had previously used EventBrite for RSVPs, but it wasn't reaching a large audience. Attendance definitely improved after switching to Meetup. I paid for that group for several years, before handing off the finances of it to Tim Curwick, the group president at the time. I hope it finds a new leader, but it seems unlikely. This group focuses on in-person meetings (with pizza!) rather than online meetings, which are available everywhere. There are probably more people like me who simply don't attend group events any more due to health risks.

Star Citizens of Minnesota found someone else to take over, which is good. I paid the bills for a few years, which is too much money gone. But I still haven't attended any of their indoor events since the pandemic started. This group is based on the Star Citizen game which has been in development since 2012, and still isn't in release yet, although some functions are playable (if you're on Windows).

I received the notice today that Twin Cities EcoClub is also looking for a new leader. I attended only one of their events. We listened to the person organizing the hydroponics container at the North Market grocery. (Aside: I know I edited photos of that event. Did I really never post it? I certainly can't find it now in Dreamwidth searches.) I remember that one was post-pandemic, because we stayed in a large spaced-apart circle outdoors to listen.

I know I've seen notices of other groups losing their leadership. Meetup will eventually delete the groups if nobody else steps up to pay the bills. It's sad to see the groups disappear, but maybe Meetup will finally stop "printing money" and reduce their rates (by a lot) to something more reasonable.

For the last few weeks, I've been using the Windows 10 beta on my home pc. The short review:


Yes, they skipped Windows 9. The most plausible explanation is that many programs may make the mistake of looking for earlier versions of windows with a search string similar to "Windows 9*", which would find instances of Windows 95 and Windows 98. Skipping ahead to Windows 10 will avoid that problem scenario where a program thinks it's running on an old system instead of a new one.

I upgraded my existing Windows 7 to Windows 10, so the process took a long time with a lot of reboots. Afterwards, performance was awful. It was really, really slow. I started disabling services that were hogging disk access. It was automatically defragging, it was monitoring usage to "optimize" disk access... and I turned it all off if I noticed an active service that I didn't immediately need. Finally, performance was back up to Windows 7 speeds.

I started up powershell. I checked, and, it's running at version 5 now.  Yay!  I tried out the new command that linux people will recognize from Debian's "apt-get". It allows a 1-line command that will install a software program onto your computer from a centralized host. It makes software management much easier on linux, and now Microsoft has caught up. There weren't any packages available yet that I was interested in using... but the available libraries will grow with time. This feature is very nice!


The interface is still a little goofy, and I still like Windows 7 better. I can tolerate this new one, at least. The only interface issue that gave me trouble was my difficulty in detecting where the slider is located on a scrollbar. The whole thing is soft grey, and one grey is not sufficiently distinct from another grey. Click the picture on the right to see for yourself. It's a screenshot from my desktop.  I have to look for a moment before my eyes finally detect the slider in the scrollbar.

I decided to provide feedback to Microsoft about the scrollbar. Bad move! Doing so somehow tied my profile (which was previously a standalone account) to my Microsoft online account (which I never wanted). It also activated OneDrive and started syncing files on my pc to Microsoft's servers (which I definitely never wanted). I disabled it immediately:


I also took back control of my profile by disconnecting the Microsoft online account:


I've decided that Windows 10 is passable. There's no compelling reason to upgrade to Windows 10... except the eventual shutdown of support for Windows 7 by Microsoft. Welcome to the future. Hurrah?

I wrote a Powershell script to convert my Firefox browser bookmarks into shortcut files on my hard drive. I was getting too large a collection, and saving new bookmarks was finally taking obviously more-than-zero time to process. From now on, I'll just drag shortcuts into folders for easier sorting and searching.

Powershell V3 includes new JSON commands, but they didn't work because my data store was too large. I had to use a 3-line command instead of a 1-line command to do the same thing, so it was an easy workaround. I retained the same directory structure and creation timestamp as in my bookmarks, too. I didn't bother with webpage icons, but the script could be upgraded to handle those too.

---

# Convert bookmarks from Firefox browser JSON backup to Windows 7 filesystem
# This script works in PowerShell v3.

# configure these variables as needed
$sourcefile = 'p:\www\bookmarks-2013-02-16.json'
$destfolder = 'p:\www\bookmarks\'
$foldertype = 'text/x-moz-place-container' # specific to Mozilla Firefox browser

# unix epoch time is milliseconds since 1970-01-01 00:00:00 GMT
# http://www.epochconverter.com/
$epoch  = [datetime]'1970-01-01'

# i found that a delay was necessary, otherwise errors cropped up occasionally
$delay = 10 # milliseconds

function CheckNodeType([object]$node, [string]$parent) {
    if ($node.type -eq $foldertype) {
        ProcessDirectory $node $parent
    } else {
        ProcessBookmark $node $parent
    }
}

function ProcessDirectory([object]$node, [string]$parent) {
    # remove bad characters from directory names
    $fixname = [system.text.regularexpressions.regex]::replace($node.title,"[^1-9a-zA-Z._]","")
    $dir = $parent + $fixname + '\'
    if (-not (test-path $dir)) {
        new-item -name $fixname -path $parent -itemtype 'directory'
        $offset = $node.dateAdded / 1000000
        $time   = [timezone]::CurrentTimeZone.ToLocalTime($epoch.AddSeconds($offset))
        sleep -Milliseconds $delay
        Set-ItemProperty -path $dir -name CreationTime -value $time
    }
    foreach($subnode in $node.children) {
        CheckNodeType $subnode $dir
    }
}

function ProcessBookmark([object]$node, [string]$parent) {
    # remove bad characters from filenames
    $fixname = [system.text.regularexpressions.regex]::replace($node.title,"[^1-9a-zA-Z. _]","")
    # truncate excessive filename lengths
    if ($fixname.Length -gt 200) {
        $fixname = $fixname.substring(0,200)
    }
    # process the good filename
    $file = $parent + $fixname + '.url'
    if (-not (test-path $file)) {
        $data = "[InternetShortcut]`nURL="+$node.uri
        new-item -name ($fixname + '.url') -path $parent -itemtype 'file' -value $data
        $offset = $node.dateAdded / 1000000
        $time   = [timezone]::CurrentTimeZone.ToLocalTime($epoch.AddSeconds($offset))
        sleep -Milliseconds $delay
        Set-ItemProperty -path $file -name CreationTime -value $time
        Set-ItemProperty -path $file -name LastWriteTime -value $time
    }
}

# read the JSON-formatted text string from the bookmark backup file
$json  = get-content $sourcefile

# the native ConvertFrom-Json command does not work on very large JSON stores, so use this method instead
[Reflection.Assembly]::LoadWithPartialName("System.Web.Extensions") | out-null
$jsser = New-Object System.Web.Script.Serialization.JavaScriptSerializer
$jsser.MaxJsonLength = $json.Length
$tree  = $jsser.DeserializeObject($json)

# process the object tree
$menu  = $tree.children | where { $_.title -eq 'Bookmarks Menu' }
foreach($node in $menu.children) {

    # ignore management folders
    if (($node.title -ne 'Recently Bookmarked') -and 
        ($node.title -ne 'Recent Tags') -and 
        ($node.title -ne 'JSTOR liberator')) {

        CheckNodeType $node $destfolder
    }
}

---

It took several more hours than I expected to get that script working, but it works well.  I like my bookmark folders.  I expect to do some manual work to create a better sorting nomenclature for them.

Can a powershell script determine if it's running in an interactive environment or not? I have a few methods that get close to the answer, but nothing offers satisfying certainty yet.

Code	Explanation
$host.name	powershell.exe yields 'ConsoleHost' powershell_gui.exe yields 'Windows PowerShell ISE Host' Each program, however, can operate in either batch or interactive conditions.
$process = gwmi win32_process -filter "ProcessID=$pid" $batch = $process.commandline -match "-NonInteractive"	If someone programs the scheduled task with the "-NonInteractive" parameter, then the script can successfully read that parameter.  It's not the default, though.
$host.runspace.runspacestateinfo $host.runspace.runspaceavailability	I always find the state info as 'Opened'. In gui conditions, availability has always been 'Busy'. In batch conditions, though, it is 'Available'.  Can I rely on this indicator?

I need to know, because I want to separate hardcoded userid/password combinations from my scripts.  I want to put them into the parameter of the scheduled task instead.  When testing those same scripts interactively, though, I want the script to prompt me for the data that it didn't receive through parameters.

Any script stuck at a user prompt is a Bad Thing [tm] when running in batch mode, since no one will ever answer it.  Using the '-NonInteractive' parameter is a good idea for all batch PowerShell scripts for this reason.  It seems to just suppress any command (or the partial execution of it) that would require user input.  I didn't even know this parameter existed until today.  It would have prevented an error in a production script that got stuck prompting for permission to delete a subfolder that I never expected to be there.  My script would have skipped that subfolder and gone on its merry way doing other things.

It still doesn't answer my question, though.  Is there a reliable way to tell if my script is running interactively or not?  Yes, it's a bit like asking which kind of virtual reality I live in, but sometimes it is important to know the distinction.  :)  Does anyone have the answer?

edit 2012.10.19: I forgot to mention previously, but someone on g+ pointed me to a webpage where contributors mentioned a few ways of dealing with this problem.  Among the solutions was one that works:  [environment]::userinteractive.

The more I learn about phone system technology, the more I wonder how anything ever works (successfully).

Among the hodge-podge of responsibilities I have at my job, I also manage 6 PBX phone systems of the Mitel / Intertel CS-5000 family. Thanks to a useful hint that my boss found in a Perl script via Google, I was able to establish phone system logging using Powershell. My programming will save us over $10,000 that we would have been charged by our vendor. That's half my annual salary, so I've earned my keep for a while. :)

I've redacted some of the details from my code for security reasons, but I wanted to make the source code public so it's easier for the next person to find useful material through a web search engine.

# log-smdr.ps1
# This Powershell script connects to a Mitel/Intertel CS-5000 series phone system, 
# directs it to open its SMDR stream, then logs the results to a text file.
# Station Message Detail Recording (SMDR) is a system feature that provides 
# a detailed record of outgoing and incoming calls.
# This script is intended to be restarted at midnight each night.

# Turning on SMDR reporting is a two-step process in DbStudio Session Manager.
# 1) System / Maintenance / SMDR, set "SMDR Output Active" to yes
#    ("Output Port" should already be set to "NONE")
# 2) System / Sockets / SMDR, set "Enable" to yes
#    (System / Cabinet / Sockets / SMDR, in some older systems)

# http://technologyordie.com/mitel-5000-smdr-script (example perl script)
# http://www.codeproject.com/Articles/12893/TCP-IP-Chat-Application-Using-C

param ([string]$site='needparm', [string]$logdir='C:\script\log\', [boolean]$debug=$false)

# convert $site parameter into ip/port combination
switch ($site) {
    'S1' { $ip='192.168.0.1'; $port=4000 }
    'S2' { $ip='192.168.0.1'; $port=4000 }
    'S3' { $ip='192.168.0.1'; $port=4000 }
    default { $ip='192.168.0.1'; $port=4000 }
}

# find a new filename for logging this session
$scriptps1 = $MyInvocation.MyCommand.Name
$scriptname = $scriptps1.substring(0,($scriptps1.length - 4))
$datelog = get-date -f 'yyyyMMdd'
$version = 0
do {
    $version += 1
    $filelog = $logdir + $scriptname + '.' + $datelog + '.' + $site + '.' + $version + '.txt'
} while (test-path $filelog)
set-content $filelog $null
if ($debug) {write-host 'logfile:' $filelog}

# create a tcp socket and a destination
# fyi, the TcpClient object did not work with SMDR (perhaps some default values interfered?)
# so I took it down a layer to the Socket object which works nicely
$sockfam  = [System.Net.Sockets.AddressFamily]::InterNetwork
$socktype = [System.Net.Sockets.SocketType]::Stream
$sockpro  = [System.Net.Sockets.ProtocolType]::TCP
$socket   = New-Object System.Net.Sockets.Socket $sockfam, $socktype, $sockpro
$ipaddr   = [System.Net.IpAddress]::Parse($ip)
$ipdest    = New-Object System.Net.IPEndPoint $ipaddr, $port

# establish the connection
if ($debug) {write-host 'connecting:' $ip ':' $port}
$socket.Connect($ipdest)
if ($socket.Connected -eq $false) {
    if ($debug) {write-host 'connection: FAILED'}
    return
}
if ($debug) {write-host 'connection: OPEN'}

# send the SMDR command ASCII character string (no password)
#     2  	002	02	00000010	STX	Start of Text
#     0  	000	00	00000000	NUL	Null char
#     132	204	84	10000100	„	Double low-9 quotation mark
$cmd = @([byte]2,[byte]0,[byte]0,[byte]0,[byte]132,[byte]0)
$socket.Send($cmd)
if ($debug) {write-host 'connection: CMD SENT'}

# the socket's .Receive() will Block, causing the program to freeze until bytes are received,
# so set up a stream which provides the useful .DataAvailable property instead
# incoming records are always 86 bytes long
$bytes = new-object System.Byte[] 86
$stream = new-object System.Net.Sockets.NetworkStream($socket)

do {
    start-sleep -m 1000
    if ($stream.DataAvailable) {
        $socket.Receive($bytes) | out-null  # script hangs here until bytes are received
        $result = [System.Text.Encoding]::ASCII.GetString($bytes[0..84]) # ignore trailing CR/LF
        if ($debug) {write-host $result}
        add-content $filelog $result # append data to text log file
    }
    $datetest = get-date -f 'yyyyMMdd'
} while ($datetest -eq $datelog)

if ($debug) {write-host 'connection: CLOSING'}
$socket.close()
if ($debug) {write-host 'connection: CLOSED'}
$socket = $null

You turn on SMDR by using the DbStudio Session Manager software that comes with your PBX system. That application directory also contains \DiagMon\Diagmon.exe, a program that can also be used to monitor (but not log, that I can tell) SMDR output from your phone panels. I intend to use DiagMon with packet sniffing software to reverse engineer the protocol for handling password-enabled SMDR. It's really hard to come by programmer-focused PBX documentation. I even contacted Mitel, but they defer to local vendors who have a financial disincentive to provide such documentation. :(

Here's a redacted version of the debug output from this script:

connecting to 192.168.0.1 : 4000
connection: OPEN
6
connection: CMD SENT
Q   Station Message Detailed Recording                          17:01:24 04-07-2012
Q    TYP EXT#  TRUNK DIALED DIGITS                START ELAPSED   COST  ACCOUNT CODE
Q
R   NET 1234  P0001 94567                        17:11 00:03:34 $00.00
R   NET 1234  P0001 95678                        17:16 00:00:09 $00.00
R   NET 2345  P0001 96789                        17:21 00:00:14 $00.00
R   IN  3456  90001                              17:19 00:04:56 $00.00

My next project will take these .TXT log files, parse them, and store the data fields in a SQL Server table. Then I can do lots of fun stuff like calculate the average length of time that people are spending in our phone tree before they reach a live person, or determine if people are hanging up in frustration before reaching any person.

Take note: This may be the only good thing that I ever say about Microsoft products.

I like Windows PowerShell.

I downloaded it last night and played around with it a bit.  Instead of manipulating text strings like other shells, this one manipulates objects.  I suppose that various operating systems are just too different to come up with a common command set to make a cross-platform list of shell commands.  Still, I like it even if it is Windows-specific.