farrellit.net

not_a_saml_app with a valid SAML App Id from the Admin Console is a transient error

Fri, 24 Aug 2018 00:00:00 -0500

I was attempting to follow https://support.google.com/a/answer/6194963 and https://aws.amazon.com/blogs/security/how-to-set-up-federated-single-sign-on-to-aws-using-google-apps/ to set up SSO from a G Suite account to an AWS account. The AWS documentation was a little outdated on the google end ( so was Google’s ) but I eventually got it going. But the thing that gave me the most issue was the error ‘not_a_saml_app’ from Google when following the App link to my newly configured Saml app.

I did some sleuthing and could only come up with one reference to this issue, https://productforums.google.com/forum/#!topic/apps/J1ek7VY1FzA;context-place=forum/Apps. The thread is locked and it doesn’t offer a solution, but it suggests talking to Google Suite support, which I did. The tech on the other end of the chat didn’t know what it meant either, but I had noticed I got the same error if I changed the Saml App ID in the URL to a bogus but valid-looking value ( like adding a number). This made me hypothesize that the problem was a lag in distributing the settings on Google’s end.

Sure enough, this error disappeared within a few hours. I hope this page can help someone else in the same position.

Golang SQL Results from Unknown Rows

Sun, 12 Aug 2018 00:00:00 -0500

I had a devil of a time figuring out how to get go’s sql query results into a json result set without having to define a structure around it. Perhaps it can help others.

The thing that confused me the most was the sql.Columns.ScanType() function, which I had convinced myself would be critical to the process. In the end, neither it, nor the reflect package defining its return type, was required.

Instead, I create colvals, a []inteface{} to satisfy rows.Scan(), and populate it with pointers to interfaces I had gotten from new(interface{}). Once rows.Scan(colvals...) returns, the value at each interface pointer is an interface that wraps the correct type for the data.

Storing all the rows as a []map[string]interface{} allows me to return json ofall the results like an API might, but without having to model my schema in golang types. I’m really excited to be able to define APIS without a lot of data odeling!

package main

import (
  "database/sql"
  "encoding/json"
  "fmt"
  _ "github.com/lib/pq"
)

// we need some data to query; I'll create a temp table
// and populate
func CreateTable(tx *sql.Tx) {
  if _, err := tx.Exec(
    `CREATE TEMPORARY TABLE test (
      id    SERIAL PRIMARY KEY,
      name  TEXT,
      date  TIMESTAMP WITH TIME ZONE )`,
  ); err != nil {
    panic(err)
  }
  for _, name := range []string{"Maddie", "Dan"} {
    if _, err := tx.Exec(
      "INSERT INTO test (name, date) VALUES ($1, NOW() )", name,
    ); err != nil {
      panic(err)
    }
  }
}

func main() {
  // docker run --rm -d p localhost:5432:5432 postgres
  conn, err := sql.Open(
    "postgres",
    "sslmode=disable host=localhost port=5432 user=postgres",
  )
  if err != nil {
    panic(err)
  }
  tx, err := conn.Begin()
  if err != nil {
    panic(err)
  }
  CreateTable(tx)
  rows, err := tx.Query("SELECT * FROM test")
  if err != nil {
    panic(err)
  }
  cols, err := rows.Columns()
  if err != nil {
    panic(err)
  }
  // we"ll want to end up with a list of name->value maps, a la JSON
  // surely we know how many rows we got but can"t find it now
  allgeneric := make([]map[string]interface{},0)
  // we"ll need to pass an interface to sql.Row.Scan
  colvals := make([]interface{}, len(cols))
  for rows.Next() {
    colassoc := make(map[string]interface{}, len(cols))
    // values we"ll be passing will be pointers, themselves to interfaces
    for i, _ := range colvals {
      colvals[i] = new(interface{})
    }
    if err := rows.Scan(colvals...); err != nil {
      panic(err)
    }
    for i, col := range cols {
      colassoc[col] = *colvals[i].(*interface{})
      fmt.Printf("%s: %T %s\n", col, colassoc[col], colassoc[col] )
    }
    fmt.Println(colassoc)
    allgeneric = append(allgeneric, colassoc)
  }
  rows.Close()
  if err := tx.Commit(); err != nil {
    panic(err)
  }
  j, err := json.Marshal(allgeneric)
  if err != nil{
    panic(err)
  }
  fmt.Println(string(j))
}

Don't Match Yourself, Grep!

Tue, 30 Jan 2018 00:00:00 -0600

If you tend to ps|grep, you’ve probably noticed it tends to match its own process, because the search string matches itself:

$ ps -a | grep worker.go
16849 ttys002    0:00.14 go run worker.go
16917 ttys004    0:00.00 grep worker.go

We were looking for the top one - but the grep matched itself too. if you were planning on sending the output through a pipeline, you’re going to end up with an additional entry for grep itself.

The most elegant solution I’ve found requires only 2 more characters. If you merely turn one of the characters in your search term into a character set containing only that character, your search term won’t match itself. For instance:

$ ps -a | grep [w]orker.go
16984 ttys002    0:00.14 go run worker.go

Perhaps it’s a bit obscure, but it works. Just remember this won’t be compatible with grep -F; since it disables regexes and does an exact text match, it won’t work with a character set (eg [w]). If it’s not an option , you could stoop to using the clumsy invocation:

ps -a | grep -F ... | grep -v grep

My Pets are Cattle

Fri, 28 Oct 2016 00:00:00 -0500

My pets are cattle.

To be more accurate, I’ve really just replaced my pets with cattle.

You see, I’ve always been enamoured with the idea of keeping unixy systems as pets, by which I mean linux (though I’ve dabbled with the freer BSDs, they never really caught on with me). I thoroughly enjoyed giving them names, unique personalities, and individual tasks.

How fun it was, to learn how to operate systems leveraging free software to deliver common web services like email, dns, http…

And I learned a lot. I learned enough that I could get paid to do it.

Then it stopped being nearly as fun.

Over the years, I found that I didn’t want to have to care for pets. They require constant walking ( read: administration ) and feeding ( read: paying bills for scanty internet access ). They got sick ( read: outdated ) and I had to heal ( read: fix ) them. If I didn’t, they’d become so ill that it was very difficult to heal them. Then, I had to euphanize ( read: reinstall ).

So now, I’ve replaced them with cattle.

I do miss the days when it seemed romantic to have ones own little network, with fun quirkly little names for the hosts based on some overly-carefully considered naming convention. At one point I had several, perhaps over a dozen, little diskless servers ( hard disks were expensive or very old and slow and prone to failure - but the motherboards tended to be stable ) all running Folding at Home or what have you. I even went so far as to diskless boot my router ( which, in retrospect, would have been less painful if it wasn’t also doing DHCP and DNS for the network). I can still remember the joy with which I watched my first diskless, PXE-booting kernel come to live without panicking.

They were good days, and productive. I was able to aquire not just the specific appied knowledge of the vairous systems ( now mostly outdated, of course ), but also the _meta_knowledge of how to aquire the knowledge one needs to install and configure systems one’s not seen before.

But all good things must come to an end. To me, it was a sad end, with a few remaining decreped servers faithfully carrying out their old, decreped tasks, and a big old heap of junk for the heavy metals reclamation folks ( I’d guess the old motherboards were worth about as much money as it cost to drive them to the recycling center, but maybe I came out ahead ). I had found my skills to be valuable to others, and when I had thier problems to solve, and the prospect of inventing my own was a lot less appealing. Slowly, my servers were consolidated, and all but a few, summarily decommissioned.

These days, I prefer to minimize special snowflakes, prefering the consistency of raindrops instead. They’re a lot less pretty , but they have a tendency to be easy to create, and therefore easy to maintain. I find that decent automation makes generating the servers I need painless, and I strive to consume services that are both cost effective and maintenance free.

For example, this website runs on S3. I generate it using a docker container ( so that I can descirbe how to install and execute jekyll in a reliable, repeatable fashon ) and then run it on an S3-hosted website for pennies a month.

Pets are fun, but cattle are economical in terms of both time and money. After a point, that’s what’s important.