Mattermost restricted access to old messages after 10000 limit is reached

    diff --git a/server/channels/app/limits.go b/server/channels/app/limits.go
    index b13103898a..a8be8dd908 100644
    --- a/server/channels/app/limits.go
    +++ b/server/channels/app/limits.go
    @@ -36,17 +36,6 @@ func (a *App) GetServerLimits() (*model.ServerLimits, *model.AppError) {
                    limits.MaxUsersHardLimit = licenseUserLimit + int64(extraUsers)
            }
     
    -       // Check if license has post history limits and get the calculated timestamp
    -       if license != nil && license.Limits != nil && license.Limits.PostHistory > 0 {
    -               limits.PostHistoryLimit = license.Limits.PostHistory
    -               // Get the calculated timestamp of the last accessible post
    -               lastAccessibleTime, appErr := a.GetLastAccessiblePostTime()
    -               if appErr != nil {
    -                       return nil, appErr
    -               }
    -               limits.LastAccessiblePostTime = lastAccessibleTime
    -       }
    -
            activeUserCount, appErr := a.Srv().Store().User().Count(model.UserCountOptions{})
            if appErr != nil {
                    return nil, model.NewAppError("GetServerLimits", "app.limits.get_app_limits.user_count.store_error", nil, "", http.StatusInternalServerError).Wrap(appErr)

so not only did they enforce a ridiculously small message limit, they also did it for the self-hosted version, and they did it without announcing it AND without a suitable migration path

and still no one from that company has admitted to it being a mistake?

very nice

I used to use Mattermost. Highly recommend looking at Zulip as an alternative. (It’s my favourite slack alternative and even better than Slack because it’s the best at managing distractions IMO. It also has an interesting history was acquired by Dropbox and then back from Dropbox I believe)

You can switch to https://framagit.org/framasoft/framateam/mostlymatter which doesn't have the user limit crap.

Bait contributors by a FOSS-like model, then switch the mode to sell the results of their contributions without paying them back. What a classic.

They're now a defense contractor, the copy on their website sounds like military cosplaying.... Probably chasing the stupid profits of Anduril and Palantir, and doing the old open source rugpull in the process.

Zulip (for Slack) and Wekan (for Trello) are good replacements, save yourself the ethical and technical worries.

https://zulip.com/

https://wekan.github.io/

Mattermost is MIT licensed. What is stopping anyone from removing this restriction?

This seems to be only for the Enterprise edition. The "free" Team edition should not have this limit:

https://github.com/mattermost/mattermost/issues/34271#issuec...

Also one of the comments:

> Would be a shame if someone with too much time on their hands dug into the binary and added a few zeroes to the message limit

Can this be done via some binary-patch tool? Really curious. It would save recompile efforts.

edit: link

edit 2: I just realized, their Ubuntu repository only contains the Enterprise edition labeled "Free edition". This is really confusing. I does look like entishitification has started long ago: https://docs.mattermost.com/deployment-guide/server/deploy-l...

What's mattermost? People in the GitHub comments say "I just need messages" but there's lots of self hosted messaging apps/servers, no? XMPP comes to mind immediately.

For all the bad press element/matrix has been getting, I am happy that at least I don't have to deal with this as well.

The good ole VC OS Rug Pull. Classic.

It’d be nice if Mozilla (or a similar foundation) could create a baseline OS platform for a business communications suite.

Years ago I used to work at a company that used Mattermost for internal chats.

Being laid off from there was sad, but at least I didn't have to use Mattermost anymore.

GitHub needs a better flag for license stuff like this. Open Source doesn’t mean what it used to.

It's another level of insane to put hard limits for self hosted open source software. I'm surprised so few people in the thread have just changed the source code and build it themselves.

I looked at it for company chat and data, but those weird limits in functionality making in unusable was just too much, so them doing this too is not really surprising. Are they low on money?

Story time. This has basically nothing to do with this post other than it involves a limit of 10,000 but hey, it's Christmas and I want to tell a story.

I used to work for Facebook and many years ago people noticed you couldn't block certain people but the one that was most public was Mark Zuckerberg. It would just say it failed or something like that. And people would assign malice or just intent to it. But the truth was much funnier.

Most data on Facebook is stored in a custom graph database that basically only has 2 tables that are sharded across thousands of MySQL instances but most almost always accessed via an in-memory write-through cache, also custom. It's not quite a cache because it has functionality built on top of the database that accessing directly wouldn't have.

So a person is an object and following them is an edge. Importantly, many such edges were one-way so it was easy to query if person A followed B but much more difficult to query all the followers of B. This was by design to avoid hot shards.

So I lied when I said there were 2 tables. There was a third that was an optimization that counted certain edges. So if you see "10.7M people follow X" or "136K people like this", it's reading a count, not doing a query.

Now there was another optimization here: only the last 10,000 of (object ID,edge type) were in memory. You generally wanted to avoid dealing with anything older than that because you'd start hitting the database and that was generally a huge problem on a large, live query or update. As an example, it was easy to query the last 10,000 people or pages you've followed.

You should be able to see where this is going. All that had happened was 10,000 people had blocked Mark Zuckerberg. Blocks were another kind of edge that was bidirectional (IIRC). The system just wasn't designed for a situation where more than 10,000 people wanted to block someone.

This got fixed many years ago because somebody came along and build a separate system to handle blocking that didn't have the 10,000 limit. I don't know the implementation details but I can guess. There was a separate piece of reverse-indexing infrastructure for doing queries on one-way edges. I suspect that was used.

Anyway, I love this story because it's funny how a series of technical decisions can lead to behavior and a perception nobody intended.

Thank god i didn't convince my team to selfhost mattermost instead of using slack

IRC, email and XAMPP solved messaging a long time ago. Derivative products built on these protocols should have solved the chat problem for most orgs, but we got complacent and thus vulnerable to nickle and diming by the likes of Saleforce and Microsoft. Now rug pulls by faux-opensource projects that basically want free labor for their commercial project so they can sell it to bigger fish.

It's not people wanting to make more money that I despise. Fine, make your commercial version ten times better, I don't care. But the practice of crippling your opensource offering by removing features or adding limits is evil and shameful.

Am I understanding this right that the main complainant in that issue thread is an IT company that wants to resell the (free) version of Mattermost software and is now complaining that they have to pay?

At first they tried to say that "we're a school" and then when the MM rep said they have an Education license, they admitted that they are not actually a school, but rather a consulting company that is gouging schools by overcharging for open source software.

From the readme.md

> A new compiled version is released under an MIT license every month on the 16th.

What does than even mean? Is it equivalent to what we use to call "freeware". Is it legal to modify the binaries?

this is not the only such recent change. can't make voice calls in public channels anymore either, only pms.

can someone clarify the situation that self-hosted free (as in beer) community mattermosts are/will be in?

Did they take VC money?

Another project bites the dust. They will return after a fork will get way popular. In time

So, they limit the access to data on self hosted instances after upgrade? Sounds like a ransomware with extra steps.

Enshitification ensues.

Y’know I’m starting to think that every single migration from paid to free software, will end up in the same cycle of becoming feature-locked. People time and again fail to understand that you need to financially support projects you use for sustainable futures. But alas, here we are…

Another option is the open source Rocket.Chat.

I was about to propose to deploy this as a company chat to my current boss, the self-hosted edition. So, is this still the best option (considering this can be reverted back, I assume), or should I just seek elsewhere now?

This seems like a poorly hashed out plan, but I do have some sympathy...

in the face of competitors with many more employees and seemingly endless piles of VC money, how do open source projects like this fund themselves? What could Mattermost do instead? Should they take more money and race everyone towards the same cliff?

Are projects like this doomed to a small niche of people who understand the implications (and meanwhile can't contribute enough to ensure development keeps pace)?

Everyone else is just going to keep using Slack, and arguably outside of these niche concerns, it's a better funded and higher quality product.

Use matrix instead. Or zulip. Or xmpp. Or IRC

[dead]

> “Mattermost only got where it is today because of the open-source community.”

Not really? FOSS communities overestimate their importance on a daily basis.

Case in point: Linux. 90%+ of commits were corporate sponsored… in 2004. The pure community member does almost nothing of importance for Linux anymore; or any of these projects.