Who we are

We are the developers of Plastic SCM, a full version control stack (not a Git variant). We work on the strongest branching and merging you can find, and a core that doesn't cringe with huge binaries and repos. We also develop the GUIs, mergetools and everything needed to give you the full version control stack.

If you want to give it a try, download it from here.

We also code SemanticMerge, and the gmaster Git client.

Plastic SCM server runs .NET Core

Friday, February 28, 2020 Pablo Santos 0 Comments

UPDATE March 10, 2020: Edited the Install on macOS from tar.gz section. We updated the instructions for installing the Plastic SCM server .Net Core on macOS.
UPDATE March 2, 2020: We edited the Current limitations section because the Plastic SCM .NET Core Server includes WebAdmin, WebUI, and DevOps (mergebots) since release 8.0.16.4024.


Great news! We just published the Plastic SCM server built on .NET Core, the cross-platform, rock-solid, super-fast and officially supported framework.

The new servers are available for Linux, macOS, and Windows beginning with version 8.0.16.4017.

The new servers are fully compatible with your current installation, but as of 8.0.16.4017, they don't include WebAdmin, WebUI, and mergebots. We'll release a new version packaging these features soon. These features are available since version 8.0.16.4024.

The Linux servers are available as tar.gz and also regular packages.

Windows and macOS servers are only available as zip and tar.gz at this point. We'll make them full regular installers soon.

Benefits of the new .NET Core server

  • Much faster on Linux and macOS.
  • Much faster SSL on Linux and macOS.
  • Linux integration with systemd.

More stable and faster servers on Linux and macOS

The reason why we migrated to .NET Core is because we want to replace our current Mono-based deployments by the more stable .NET Core framework.

We've been running on Mono on Linux and macOS since 2005, and most of our biggest servers run on Linux today. But .NET Core clearly outperforms Mono in terms of stability. Now the new servers in Linux and macOS will be rock solid, much stronger than they used to be.

There's also an added benefit. We tested the new servers and found them to be 5 times faster dealing with SSL than the current Mono based ones. That's is a huge performance improvement.

How to install on Linux – using packages

If your server runs Debian, OpenSuse, Ubuntu or Fedora, then you can install normally using packages following the official instructions, except that you need to install the plasticscm-server-netcore instead.

Other than that, the installation will be straightforward.

Reminder for OpenSuse users

Since the Plastic server is now compliant with systemd, we stick to the policies of each operating system. In OpenSuse, services are disabled on installation. If you want the Plastic server to start when you reboot your system, type this: $ sudo systemctl enable plasticscm-server

Remark

Right now, we'll still have plasticscm-server-core as the official server package, but we plan to replace it with the new .NET Core based on in the coming weeks.

Remark

Yes, the official package is called plasticscm-server-core which is unfortunate because the core there has nothing to do with being .NET Core.

How to install on Linux using tar.gz

  1. Download the .tar.gz from the website:

    Or alternatively, run a wget:

    $ wget <a href="https://s3.eu-west-2.amazonaws.com/plastic-releases/releases/8.0.16.4017/plasticscm/linux/PlasticSCM-8.0.16.4017-linux-x64-server-netcore.tar.gz">
    

    Where instead of 4017, you should use the latest version available.

  2. Unzip the package
    $ tar xvf PlasticSCM-8.0.16.4017-linux-x64-server-netcore.tar.gz
    

    This will place the binaries inside the server directory. You can obviously choose the location you want.

  3. Set plasticd as executable
    $ cd server
    $ chmod u+x plasticd
    
    Remark

    This is something will fix in upcoming versions.

  4. Run plasticd configure to configure the server
    $ plasticd configure
    
  5. Create a jet.conf. Something like this:
    $ cat jet.conf
    
    basepath=/home/pablo/server/jet
    
  6. Start your server:
    $ plasticd --console
    

Now you have a fully functional Plastic server.

In case you want to replace your current running server, then use the same configuration files you were already using (server.conf, plasticd.lic, users.conf, groups.conf, remoting.conf, etc).

Configure systemd from the Linux tar.gz

The new server is fully integrated with systemd.

When you install from the packages, the integration happens behind the scenes.

If you install from tar.gz and want to integrate with systemd, follow the following steps after unzipping and configuring your server.

  1. Edit plasticscm-server.service. This is a file that comes included in the tar.gz:
    $ cat plasticscm-server.service
    
    [Unit]
    Description=Plastic SCM Server
    Documentation=https://www.plasticscm.com/documentation/administration/plastic-scm-version-control-administrator-guide
    After=network.target
    
    [Service]
    Type=notify
    ExecStart=/mnt/ebs/plasticnetcore/server/plasticd --daemon
    WorkingDirectory=/mnt/ebs/plasticnetcore/server
    User=ec2-user
    Group=ec2-user
    
    [Install]
    WantedBy=multi-user.target
    

    In my case I edited the ExecStart and WorkingDirectory entries to point to the location where I placed my binaries. I also edited User and Group to run as ec2-user on my Amazon server.

  2. Copy the plasticscm-server.service file to /etc/systemd/system:
    $ sudo cp plasticscm-server.service /etc/systemd/system/
    
  3. Force a reload:
    $ sudo systemctl daemon-reload
    
  4. Start the service:
    $ sudo systemctl start plasticscm-server
    
  5. Check the status:

And you're done!

Install on macOS from tar.gz

Plastic SCM servers in macOS are not so common these days, but with this new version we feel super confident about running heavily loaded servers in this OS.

  1. Download the right tar.gz for macOS from the Plastic SCM website:
  2. Installing is quite simple: just unzip with tar xvf and the name of the file.
  3. Run plasticd.sh configure to configure the server:
    $ plasticd.sh configure
    
    Remark

    The plasticd.sh script will automatically fix binary signatures. If you are running on macOS Catalina, you'll need to tell the operating system that you trust the binaries.

    So, the following command is issued automatically with this script:

    $ xattr -d com.apple.quarantine $SERVER_NETCOREDIR
    
  4. Create a jet.conf. Something like this:
    $ cat jet.conf
    
    basepath=/home/pablo/server/jet
    
  5. Start your server:
    $ plasticd.sh --console
    

    Or even as a daemon as:

    $ plasticd.sh –daemon
    

    But the process is not installed as a service yet, we still haven't implemented that part.

Other than that, the same as happens on Linux; this is an incredibly improved server compared to what we had before.

Install on Windows from zip

At this point we still don't provide a proper Windows installer, but it is possible to take advantage of the new .NET Core based server on Windows too.

  1. Download the zip from the Plastic SCM website:
  2. Unzip it.
  3. You can already run the plasticd.exe included. Go to the command line and type:
    plasticd configure
    

    to configure the server if you are starting a fresh installation.

    Otherwise, you can copy the existing config files to the new location: server.conf, users.conf, groups.conf, plasticd.lic, remoting.conf, lock.conf, mostly all the .conf files you have.

  4. Start the server:
    plasticd --console
    

    to start it as a console process.

  5. It is also possible to convert the process into a proper windows server:
    C:\WINDOWS\system32>sc.exe create "Plastic SCM netcore" binpath=c:\users\danipen\Desktop\server\plasticd.exe
    [SC] CreateService SUCCESS
    C:\WINDOWS\system32>sc.exe start "Plastic SCM netcore"
    SERVICE_NAME: Plastic SCM netcore
            TYPE               : 10  WIN32_OWN_PROCESS
            STATE              : 2  START_PENDING
                                    (NOT_STOPPABLE, NOT_PAUSABLE, IGNORES_SHUTDOWN)
            WIN32_EXIT_CODE    : 0  (0x0)
            SERVICE_EXIT_CODE  : 0  (0x0)
            CHECKPOINT         : 0x0
            WAIT_HINT          : 0x7d0
            PID                : 6932
            FLAGS              :
    C:\WINDOWS\system32>sc.exe query "Plastic SCM netcore"
    SERVICE_NAME: Plastic SCM netcore
            TYPE               : 10  WIN32_OWN_PROCESS
            STATE              : 4  RUNNING
                                    (STOPPABLE, NOT_PAUSABLE, ACCEPTS_SHUTDOWN)
            WIN32_EXIT_CODE    : 0  (0x0)
            SERVICE_EXIT_CODE  : 0  (0x0)
            CHECKPOINT         : 0x0
            WAIT_HINT          : 0x0
    C:\WINDOWS\system32>sc.exe stop "Plastic SCM netcore"
    SERVICE_NAME: Plastic SCM netcore
            TYPE               : 10  WIN32_OWN_PROCESS
            STATE              : 3  STOP_PENDING
                                    (STOPPABLE, NOT_PAUSABLE, ACCEPTS_SHUTDOWN)
            WIN32_EXIT_CODE    : 0  (0x0)
            SERVICE_EXIT_CODE  : 0  (0x0)
            CHECKPOINT         : 0x0
            WAIT_HINT          : 0x0
    C:\WINDOWS\system32>sc.exe query "Plastic SCM netcore"
    SERVICE_NAME: Plastic SCM netcore
            TYPE               : 10  WIN32_OWN_PROCESS
            STATE              : 1  STOPPED
            WIN32_EXIT_CODE    : 0  (0x0)
            SERVICE_EXIT_CODE  : 0  (0x0)
            CHECKPOINT         : 0x0
            WAIT_HINT          : 0x0
    C:\WINDOWS\system32>
    

Configure the network with network.conf

If you've been using Plastic for a while, you'll definitely be familiar with remoting.conf, the config file to define the ports to listen, the SSL cert and a few others.

We redesigned this configuration and the new .NET Core server uses a new file named network.conf. (It converts remoting.conf into network.conf on the fly if it finds one).

This is what a simple network.conf looks like for a server listening in 8084, and then in 8088 and 8787 using SSL:

[
    {
        "Port" : 8084,
        "Type" : "Tcp",
        "Security" : "None"
        "RejectRemoteRequests" : true,
    },
    {
        "Port" : 8088,
        "Type" : "Tcp",
        "Security" : "Ssl",
        "SslPfxFile" : "plasticscm.com.pfx",
        "SslPfxFilePassword" : "xxxxxxxxxxxxxxxxxxxxxx",
        "ReceiveTimeoutMsec" : 2000,
        "SendTimeoutMsec" : 2000,
        "ReceiveBufferSizeBytes" : -1,
        "SendBufferSizeBytes" : -1
        "BindTo" : "162.165.0.1"
    },
    {
        "Port" : 8787,
        "Type" : "Tcp",
        "Security" : "Ssl",
        "SslPfxFile" : "plasticscm.com.pfx",
        "SslPfxFilePassword" : "xxxxxxxxxxxxxxxxxxxxxx",
        "ReceiveTimeoutMsec" : 2000,
        "SendTimeoutMsec" : 2000,
        "ReceiveBufferSizeBytes" : -1,
        "SendBufferSizeBytes" : -1
    }
]

Most of the fields are self-explanatory, and you can see an example of how to setup a SSL certificate.

The good news is that most of the settings are optional. A network.conf like this is also valid:

[
    {
        "Port" : 8084,
    },
    {
        "Port" : 8088,
        "Security" : "Ssl",
    }
]

And will make the server listen in port 8084 without security, and then in 8088 with SSL, autogenerating a self-signed certificate the first time it runs.

Stress tests

We ran intensive stress tests on the new server to guarantee that it performs as expected.

We tested the server for days running on Linux under the following conditions:

  • 5 million operations per hour.
  • 6000 repositories.
  • Simulated by 250 concurrent clients connected to the server. This means 250 extremely active users, not comparable with human generated load. To give you some data, this test generates more load than 3000 real users.

By comparison, we were able to crash the Mono-based build after 20 hours running this scenario, while the .NET Core one never crashed. The Mono server was able to handle 2 million ops per hour instead of 5 million.

The .NET Core based server was able to complete several runs of 4 days, non-stop.

Current limitations

8.0.16.4017 has the following limitations:

  • No installer for Windows, just a zip.
  • No installer for macOS, just a tar.gz.
  • Binaries not signed for macOS. You'll have to run a command to validate (see above).
  • No WebUI.
  • No WebAdmin.
  • No mergebots.
  • No GitServer.
  • No packages for RedHat.
  • The tar.gz works on RedHat 7.0 but not 8.0.
  • The plasticd is not set as +x in the tar.gz; you have to chmod manually.
  • Windows service has to be installed manually. The installer will fix this soon.
  • macOS server is not daemonized; we still don't provide a way to start it automatically on server start up.
  • No multi-file semantic merge in merge-to.

Still, despite these limitations, this is the best server core we have ever had.


Limitations removed in 8.0.16.4024:

  • No WebUI.
  • No WebAdmin.
  • No mergebots.
Pablo Santos
I'm the CTO and Founder at Códice.
I've been leading Plastic SCM since 2005. My passion is helping teams work better through version control.
I had the opportunity to see teams from many different industries at work while I helped them improving their version control practices.
I really enjoy teaching (I've been a University professor for 6+ years) and sharing my experience in talks and articles.
And I love simple code. You can reach me at @psluaces.

0 comentarios: