GitLab

breaking stitching.

nonlocal project/user.

wanting to call setgroups cause it is so slow. also refactor the code to
chown/chgrp user dot files so we can call it from reactivate.

Refactor the code that bumps user/project activity and calls exports
setup so that we can call it from reactivate.

When deleting a ZFS home/proj directory, do the ZFS rename and then
set the mountpoint=none, no need to have it mounted.

picked genesis. But this change actually has content; we need to
distinguish between classic projects and emulab portal projects
(new projects created via the portal, and used via the portal).  For now
these are distinct until we decide to bring everyone up to the new
interface.

update the DB only.

When zero, we do not set an expiration on passwords.

Also includes some PhantomNet-specific restrictions (e.g. only
allows use of the main Utah Emulab testbed  aggregate).

This excercise stretched the limits of what we can reasonably do
before introducing real per-testbed branding/policy mechanisms to
the php/web front-end.  My changes ain't exactly pretty...

Please take care when adding any testbed-specific changes to the
code.  There are three flavors now to consider in the logic.

use SHA265 ($5$) with a 16 character random salt from /dev/urandom.
Enabled for Utah MS for now, will push out to other clusters if no
problems over the next week.

1. Instead of a plain list of profiles, generate a more detailed list that
   includes last used and usage counts and project name and favorite flag,
   so that the new picker can be sorted/grouped.

   This list is *ordered* by most recent usage (if a real user), or most
   popular (if a guest). 

2. Move the modal from quickvm_sup to the template, and generate the
   current list from the new json info.

3. Add new table apt_profile_favorites to record favorite profiles for
   users.

4. Add new ajax calls for above, MarkFavorite and ClearFavorite that take a
   single argument, the uuid of the profile. There is no UI for this, Keith
   is going to add that.

Hopefully will prevent catastrophic DB failure as we no longer make
tens of thousands of DB queries to find the first available uid.

recently we have had a spate of errors caused by double clicks causing
duplicate entries.

which looks at environment variable to determine what user should be used
for access checks. Now used from the protogeni interface, when real
accounts are in use (but all work still done by geniuser).

it expired.

and to generate one. When generating one, look for a revoked/expired
certificate and reuse the key (and password) otherwise generate a new
key and new random password. This allows existing Emulab users who have
never used Geni, to use the APT/Cloud interface without having to create
a key via the web interface.

when regenerating your key. Also pass new flag to addpubkey to make the
key as internal.

authenticate Geni users to CloudLab (who do not have Emulab accounts).
CloudLab users must have an account to do anything (unlike APT which allows
guest users). But instead of requiring them to go through the Emulab
account creation (high bar), let then use their Geni credentials to prove
who they are. We then build a local account for that new user, and save off
the speaksfor credential so that we can act on their behalf when talking to
the backend clusters (and their MA to get their ssh keys).

These users do not have a local account password, so they cannot log into
the web interface using the Emulab login page, nor do they have a shell on
ops.

Once authenticated, we put the appropriate cookies into the browser via
javascript, so they can use the Cloud (okay, APT) web interface (they
appear logged in).

I make use of the nonlocal_id field of the users table, which was not being
used for anything else. Officially, these are "nonlocal" users in the code
(IsNonLocal()).

When a nonlocal user instantiates a profile, we use their speaksfor
credential to ask their home MA for their ssh keys, which we then store in
the DB, and then provide to the aggregate via the CreateSliver call.
Note that no provision has been made for users who edit their profile and
add keys; I am not currently expecting these users to stumble into the web
interface (yet).

start of a page to create new profiles, lots of other changes
and additions.

check to make sure the user's homedir and ssl certificate exists,
before starting a swap, but turns out the mountd problem in FreeBSD
makes that a little problematic. So lets commit the code, and hope
that FreeBSD fixes the mountd problem someday.

project/group membership. Confirm this with a confirm page. This
will solve the problem of adding a brand new user to an admins only
project, before they are an admin.

This commit is intended to makes the license status of Emulab and
ProtoGENI source files more clear.  It replaces license symbols like
"EMULAB-COPYRIGHT" and "GENIPUBLIC-COPYRIGHT" with {{{ }}}-delimited
blocks that contain actual license statements.

This change was driven by the fact that today, most people acquire and
track Emulab and ProtoGENI sources via git.

Before the Emulab source code was kept in git, the Flux Research Group
at the University of Utah would roll distributions by making tar
files.  As part of that process, the Flux Group would replace the
license symbols in the source files with actual license statements.

When the Flux Group moved to git, people outside of the group started
to see the source files with the "unexpanded" symbols.  This meant
that people acquired source files without actual license statements in
them.  All the relevant files had Utah *copyright* statements in them,
but without the expanded *license* statements, the licensing status of
the source files was unclear.

This commit is intended to clear up that confusion.

Most Utah-copyrighted files in the Emulab source tree are distributed
under the terms of the Affero GNU General Public License, version 3
(AGPLv3).

Most Utah-copyrighted files related to ProtoGENI are distributed under
the terms of the GENI Public License, which is a BSD-like open-source
license.

Some Utah-copyrighted files in the Emulab source tree are distributed
under the terms of the GNU Lesser General Public License, version 2.1
(LGPL).

* When generating an encrypted SSL certificate, derive an SSH public
  key from the private key and store in the pubkeys table for the
  user. Note that SSH version 2 RSA keys are actually just openssl RSA
  keys, and that ssh-keygen can extract an ssh compatible public key
  from it.

* Change getsslcert.php3 to return the ssh private and public key when
  give the "ssh" boolean argument. This is mostly for the benefit of
  Flack; we probably need a better UI for the user to get this stuff. 

* Remove the requirement that users must upload an SSH key to use
  protogeni, since we now create one for them when they create their
  encrypted SSL certificate.

* Some cleanup; instead of looking at the comment field to determine
  what pubkeys are Emulab created (and should not be deleted), use new
  internal and nodelete flags.

Deter.

on the join/start project pages. At the moment this is conditional
under the PROTOGENI flag, since users on non-protogeni sites rarely
need an encrypted SSL certificate. The initial passphrase has to be
store someplace since we cannot built the certificate until the user
is approved, so put it into the users table, and delete when the first
certificate is built (at approval).

slot access. 
Delete ssh and ssl keys when deleting a user.
Add BumpModified() to update usr_modified slot.
Add DeleteSSHKeys() method.

Add DefaultProject() method, which looks in the users table (new slot,
default_project). Failing that, use first approved project.

Might not be in its final form yet.

concatenated without a space.

CreateSliver(), to handle multiple accounts.  This somewhat reflects
the Geni AM API for keys, which allows the client to specify multiple
users, each with a set of ssh keys.

The keys argument to the CM now looks like the following (note that
the old format is still accepted and will be for a while).

[{'urn'   => 'urn:blabla'
  'login' => 'dopey',
  'keys'  => [ list of keys like before ]},
 {'login' => "leebee",
  'keys'  => [ list of keys ... ]}];

Key Points:

1. You can supply a urn or a login or both. Typically, it is going to
   be the result of getkeys() at the PG SA, and so it will include
   both.

2. If a login is provided, use that. Otherwise use the id from the urn.

3. No matter what, verify that the token is valid for Emulab an uid
   (standard 8 char unix login that is good on just about any unix
   variant), and transform it if not.

4. For now, getkeys() at the SA will continue to return the old format
   (unless you supply version=2 argument) since we do not want to
   default to a keylist that most CMs will barf on.

5. I have modified the AM code to transform the Geni AM version of the
   "users" argument into the above structure. Bottom line here, is
   that users of the AM interface will not actually need to do
   anything, although now multiple users are actually supported
   instead of ignored.

Still to be done are the changes to the login services structure in
the manifest. We have yet to settle on what these changes will look
like, but since people generally supply valid login ids, you probably
will not need this, since no transformation will take place.

This method looks to see if these keys were *likely* generated by us.
The regular GetSSHKeys specifically filters these out.  This new method
should be used carefully, since these keys are not passphrase-protected.
For instance, I'm only using it for loading keys on switches that are
only locally accessible right now.