Car rental in Germany – Are winter tires included?

I'm going to rent a car in Frankfurt in Germany in December-January. Can I assume that all cars must be equipped with winter tires? (The reason I ask is that some websites clearly indicate that winter tires are included, while others do not mention it at all)

tls – Creation of a certificate authority certificate, server and client – string not included? Or how to check the transmitter?

I have created CA, server and client certificates:

# set up CA
openssl req -x509 -config openssl-ca.cnf -newkey rsa:4096 -sha256 -out cacert.pem -outform PEM
touch index.txt
echo '01' > serial.txt

# create server CSR, cert
openssl req -config openssl-server.cnf -newkey rsa:2048 -sha256 -out servercert.csr -outform PEM
openssl ca -config openssl-ca.cnf -policy signing_policy -extensions signing_req -out servercert.pem -infiles servercert.csr

# create client CSR, cert
CLIENT_ID="01-test"
CLIENT_SERIAL=01

openssl genrsa -aes256 -passout pass:PasswordHere -out ${CLIENT_ID}.pass.key 4096
openssl rsa -passin pass:PasswordHere -in ${CLIENT_ID}.pass.key -out ${CLIENT_ID}.key
rm ${CLIENT_ID}.pass.key
openssl req -new -key ${CLIENT_ID}.key -out ${CLIENT_ID}.csr
openssl x509 -req -days 1000 -in ${CLIENT_ID}.csr -CA cacert.pem -CAkey cakey.pem -set_serial ${CLIENT_SERIAL} -out ${CLIENT_ID}.pem

# combine into p12 files
openssl pkcs12 -export -out servercert.p12 -in servercert.pem -inkey serverkey.pem
openssl pkcs12 -export -out 01-test.p12 -in 01-test.pem -inkey 01-test.key  

Basically, I'm https://stackoverflow.com/questions/21297139/how-do-you-sign-a-certificate-signing-reign-request-re-your-certification-authority/21340898#21340898 on behalf of Certification authority. I am looking to configure client and server certificates, both signed by the same authority, for testing purposes.

I am trying to understand how I can verify, from the point of view of the client and the server, that the remote certificate comes from the same certification authority as the local authority. The issuers agree, but I'm sure that anyone could issue a certificate with any issuer.

I understand that a chain of certificates is involved – but (in at least .NET countries), for example, in generated .pem files, I do not see any reference to the public key of the cert.

What should I do, from a logical point of view, to validate the cert issuer. I could install the certificate of the root CA in the local machine's certificate store – but instead, what exactly does an SSL library do to verify that the certificate authority issued a certificate particular, if it is not limited to the issuer?

seo – In and x-default should be included on the same page for hreflang tags?

We use a tool such as SEMRush where it reports that the en and x-default the values ​​for hreflang cause conflict.

Both en and x-default be included for the hreflang Keywords?

That's what we have now.



  





 ....


android – Analyze opening hours and eliminate lunatics (included in the OpenStreetMap editor)

This code is used to check the opening hours of data from OpenStreetMap that can be managed by an editing application. In the case where the opening hours are not too complex, the data is also transformed into a usable form.

It is part of a StreetComplete editing application. This specific file will be part of the draw request, which will add the ability to make a new review of opening hours.

Unfortunately, I did not really know how to split this file into a smaller file. It is therefore quite large and has 440 lines. Nevertheless, even the smallest comments on some of the code are welcome – even typing errors and grammatical errors in the comments.

For context, the branches of this job, including any changes, are available at https://github.com/westnordost/StreetComplete/compare/master…matkoniecz:resurvey.

Comments on how to split this into smaller parts are also welcome, but it seemed to me that any subset of these changes would remain completely unclear.

OpeningHoursTagParser.kt:

package de.westnordost.streetcomplete.quests.opening_hours

import ch.poole.openinghoursparser.*
import de.westnordost.streetcomplete.quests.opening_hours.adapter.OpeningMonthsRow
import de.westnordost.streetcomplete.quests.opening_hours.adapter.OpeningWeekdaysRow
import de.westnordost.streetcomplete.quests.opening_hours.model.CircularSection
import de.westnordost.streetcomplete.quests.opening_hours.model.TimeRange
import de.westnordost.streetcomplete.quests.opening_hours.model.Weekdays
import java.io.ByteArrayInputStream

object OpeningHoursTagParser {
    // returns null for values that are invalid or not representable in
    // StreetComplete opening hours edit widget
    // otherwise returns data structure that can be directly used to
    // initialize this editing widget
    fun parse(openingHours: String): List? {
        val rules: ArrayList
        try {
            val input = ByteArrayInputStream(openingHours.toByteArray())
            val parser = OpeningHoursParser(input)
            rules = parser.rules(false)
        } catch (e: ParseException) {
            // parsing failed, value is malformed
            return null
        }
        if (!isRulesetToStreetCompleteSupported(rules)) {
            // parsable, not handled by StreetComplete
            return null
        }
        return transformStreetCompleteCompatibleRulesetIntoInternalForm(rules)
    }

    private fun transformStreetCompleteCompatibleRulesetIntoInternalForm(rules: ArrayList): List? {
        var data = mutableListOf(OpeningMonthsRow())
        for (rule in rules) {
            if (rule.dates != null) {
                // month based rules, so we need OpeningMonthsRow objects that will be created
                // and added later rather than a single catch-all row
                data = mutableListOf()
            }
        }

        for (rule in rules) {
            var index = 0
            if (rule.dates != null) {
                Assert.assert(rule.dates.size == 1)
                val start = rule.dates(0).startDate
                val end = rule.dates(0).endDate ?: start
                index = getIndexOfOurMonthsRow(data, start.month.ordinal, end.month.ordinal)
                if (index == -1) {
                    // there is no reusable row matching out entry, we need to create a new one
                    data.add(OpeningMonthsRow(CircularSection(start.month.ordinal, end.month.ordinal)))
                    index = data.size - 1
                }
            }
            for (time in rule.times) {
                val dayData = daysWhenRuleApplies(rule)
                data(index).weekdaysList.add(OpeningWeekdaysRow(Weekdays(dayData), TimeRange(time.start, time.end)))
            }
        }

        return data
    }

    private fun getIndexOfOurMonthsRow(monthRows: List, startMonth: Int, endMonth: Int): Int {
        for ((index, row) in monthRows.withIndex()) {
            if (row.months.start == startMonth) {
                if (row.months.start == endMonth) {
                    return index
                }
            }
        }
        return -1
    }

    //returns array that can be used to initialize OpeningWeekdaysRow
    private fun daysWhenRuleApplies(rule: Rule): BooleanArray {
        val dayData = BooleanArray(8) { false }
        Assert.assert(rule.holidays != null || rule.days.size >= 0)
        if (rule.days != null) {
            Assert.assert(rule.days.size == 1)
            val startDay = rule.days(0).startDay
            val endDay = rule.days(0).endDay
                    ?: startDay // endDay will be null for single day ranges
            if (startDay <= endDay) {
                // ranges like Tuesday-Saturday
                for (day in WeekDay.values()) {
                    if (day >= startDay) {
                        if (day <= endDay) {
                            dayData(day.ordinal) = true
                        }
                    }
                }
            } else {
                // ranges like Saturday-Tuesday
                for (day in WeekDay.values()) {
                    if (day <= endDay || day >= startDay) {
                        dayData(day.ordinal) = true
                    }
                }
            }
        }
        if (rule.holidays != null) {
            Assert.assert(rule.holidays.size == 1)
            Assert.assert(rule.holidays(0).type == Holiday.Type.PH)
            Assert.assert(rule.holidays(0).offset == 0)
            Assert.assert(rule.holidays(0).useAsWeekDay)
            dayData(7) = true
        }
        return dayData
    }

    // Returns true iff supported by StreetComplete
    // Returns false otherwise, in cases where it is not directly representable
    //
    // It is first checking each rule (parts of opening_hours tag separated by ; sign)
    // is it possible to recreate it by taking only supported parts
    // later it checks also some additional limitations imposed by SC
    private fun isRulesetToStreetCompleteSupported(ruleset: ArrayList): Boolean {
        for (rule in ruleset) {
            if (reduceRuleToStreetCompleteSupported(rule) == null) {
                return false
            }
        }
        if (includesMonthsRangeCrossingNewYearBoundary(ruleset)) {
            // strictly speaking this kind of ranges are supported, but not in an obvious way
            return false
        }
        if (areOnlySomeRulesMonthBased(ruleset)) {
            // StreetComplete can handle month based rules, but requires all of them to be month based
            return false
        }
        if (rulesAreOverridingOtherRules(ruleset)) {
            // this kind of opening hours specification likely require fix
            // anyway, it is not representable directly by SC
            return false
        }
        return true
    }

    private fun includesMonthsRangeCrossingNewYearBoundary(ruleset: ArrayList): Boolean {
        for (rule in ruleset) {
            if (rule.dates != null) {
                Assert.assert(rule.dates.size == 1)
                if (rule.dates(0).endDate != null) {
                    if (rule.dates(0).startDate.month > rule.dates(0).endDate.month) {
                        return true
                    }
                }
            }
        }
        return false
    }

    private fun rulesAreOverridingOtherRules(ruleset: ArrayList): Boolean {
        for (checkedRuleIndex in 0 until ruleset.size) {
            for (competingRuleIndex in 0 until ruleset.size) {
                if (checkedRuleIndex != competingRuleIndex) {
                    if (ruleset(checkedRuleIndex).dates != null) {
                        Assert.assert(ruleset(competingRuleIndex).dates != null)
                        Assert.assert(ruleset(checkedRuleIndex).dates.size == 1)
                        Assert.assert(ruleset(competingRuleIndex).dates.size == 1)
                        val firstDateRange = ruleset(checkedRuleIndex).dates(0)
                        val secondDateRange = ruleset(competingRuleIndex).dates(0)
                        if (areMonthRangesIntersecting(firstDateRange, secondDateRange)) {
                            return areDayRangesIntersecting(ruleset(checkedRuleIndex), ruleset(competingRuleIndex))
                        }
                    } else {
                        Assert.assert(ruleset(competingRuleIndex).dates == null)
                        return areDayRangesIntersecting(ruleset(checkedRuleIndex), ruleset(competingRuleIndex))
                    }
                }
            }
        }
        return false
    }

    private fun areDayRangesIntersecting(ruleA: Rule, ruleB: Rule): Boolean {
        if (areHolidaysIntersecting(ruleA.holidays, ruleB.holidays)) {
            return true
        }
        if (ruleA.days == null || ruleB.days == null) {
            return false
        }
        Assert.assert(ruleA.days.size == 1)
        Assert.assert(ruleB.days.size == 1)
        val weekDayRangeA = ruleA.days(0)
        val weekDayRangeB = ruleB.days(0)
        val startA = weekDayRangeA.startDay
        val endA = weekDayRangeA.endDay ?: startA
        val startB = weekDayRangeB.startDay
        val endB = weekDayRangeB.endDay ?: startB
        val rangeA = CircularSection(startA.ordinal, endA.ordinal)
        val rangeB = CircularSection(startB.ordinal, endB.ordinal)
        return rangeA.intersects(rangeB)
    }

    private fun areHolidaysIntersecting(firstHolidays: MutableList?, secondHolidays: MutableList?): Boolean {
        if (firstHolidays == null || secondHolidays == null) {
            return false
        }
        for (holiday in firstHolidays) {
            for (holidayCompeting in secondHolidays) {
                Assert.assert(holiday.useAsWeekDay)
                Assert.assert(holidayCompeting.useAsWeekDay)
                Assert.assert(holiday.offset == 0)
                Assert.assert(holidayCompeting.offset == 0)
                if (holiday.type == holidayCompeting.type) {
                    return true
                }
            }
        }
        return false
    }

    // all info in dates, except months is ignored!
    private fun areMonthRangesIntersecting(aDateRange: DateRange?, bDateRange: DateRange?): Boolean {
        if (aDateRange == null || bDateRange == null) {
            return false
        }
        val startA = aDateRange.startDate
        val endA = aDateRange.endDate ?: aDateRange.startDate
        val startB = bDateRange.startDate
        val endB = bDateRange.endDate ?: bDateRange.startDate
        val rangeA = CircularSection(startA.month.ordinal, endA.month.ordinal)
        val rangeB = CircularSection(startB.month.ordinal, endB.month.ordinal)
        return rangeA.intersects(rangeB)
    }

    private fun areOnlySomeRulesMonthBased(ruleset: ArrayList): Boolean {
        var rulesWithMonthLimits = 0
        for (rule in ruleset) {
            if (rule.dates != null) {
                rulesWithMonthLimits += 1
            }
        }
        if (rulesWithMonthLimits == 0) {
            return false
        }
        if (rulesWithMonthLimits == ruleset.size) {
            return false
        }
        return true
    }


    // Reduces rule to a subset supported by StreetComplete
    // in case of any info that would be lost it returns null
    // null is also returned in cases where conversion would be necessary
    // and there is any risk of loss of any data
    private fun reduceRuleToStreetCompleteSupported(rule: Rule): Rule? { // following are ignored:
        val returned = emptyRule()
        if (rule.days == null && rule.holidays == null) {
            // SC requires explicit specification of days of a week or PH
            // holidays may contain some other holidays, but such cases will
            // fail a holiday-specific check
            return null
        }
        if (rule.days != null) {
            val simplifiedWeekDayRanges: MutableList = ArrayList()
            for (weekDayRange in rule.days) {
                val simplifiedDateRange = reduceWeekDayRangeToSimpleDays(weekDayRange)
                        ?: return null
                simplifiedWeekDayRanges.add(simplifiedDateRange)
            }
            if (simplifiedWeekDayRanges.size > 1) {
                //TODO: support also Fr,Sa 11:00-00:00 kind of rules
                return null
            }
            returned.days = simplifiedWeekDayRanges // copy days of the week from the input rule
        }
        if (rule.dates != null) {
            val simplifiedDateRanges: MutableList = ArrayList()
            for (dateRange in rule.dates) {
                val simplifiedDateRange = reduceDateRangeToFullMonths(dateRange) ?: return null
                simplifiedDateRanges.add(simplifiedDateRange)
            }
            if (simplifiedDateRanges.size > 1) {
                // happens with rules such as `Mo-Fr 7:30-18:00, Sa-Su 9:00-18:00`
                // that are intentionally rejected as are not directly representable in SC
                // and handling them may result in unexpected silent transformation
                // what is unwanted
                return null
            }
            // TODO: replace by setDates from https://github.com/simonpoole/OpeningHoursParser/releases/tag/0.17.0 once available
            // it should appear on for example https://bintray.com/simonpoole/osm/OpeningHoursParser once uploaded
            returned.setMonthdays(simplifiedDateRanges)
        }
        if (rule.times == null) {
            // explicit opening hours are required by SC
            return null
        } else {
            val simplifiedTimespans: ArrayList = ArrayList()
            for (time in rule.times) {
                val simplifiedTimespan = reduceTimeRangeToSimpleTime(time) ?: return null
                simplifiedTimespans.add(simplifiedTimespan)
            }
            // multiple timespans may happen for rules such as "Mo-Su 09:00-12:00, 13:00-14:00"
            returned.times = simplifiedTimespans
        }
        if (rule.modifier != null) {
            val modifier = reduceModifierToAcceptedBySC(rule.modifier) ?: return null
            returned.modifier = modifier
        }
        if (rule.holidays != null) {
            val holidays = reduceHolidaysToAcceptedBySC(rule.holidays) ?: return null
            returned.holidays = holidays
        }
        return if (rule == returned) {
            // original rule is matching reduced rule as no special constructions were used
            returned
        } else {
            // not representable given our limitations
            null
        }
    }

    private fun reduceModifierToAcceptedBySC(modifier: RuleModifier): RuleModifier? {
        // public holidays with "off" specified explicitly are incompatible with SC due to
        // https://github.com/westnordost/StreetComplete/issues/276
        // other opening hours using "off" are rare and would require automated conversion
        // that would drop off part, what may cause issues in weird cases
        if (modifier.modifier != RuleModifier.Modifier.OPEN) {
            return null
        }
        return modifier
    }

    private fun reduceHolidaysToAcceptedBySC(holidays: List): List? {
        // PH, with set opening hours variant is supported by SC
        // many other variants are not, holidays list longer than 1 entry
        // indicates unsupported use
        if (holidays.size > 1) {
            return null
        }
        val holiday = holidays(0)
        val returned = Holiday()
        if (!holiday.useAsWeekDay) {
            // SC is not supporting "public holidays on Mondays" combinations
            return null
        }
        returned.useAsWeekDay = true
        if (holiday.type != Holiday.Type.PH) {
            // SC is not supporting SH
            return null
        }
        returned.type = Holiday.Type.PH
        return listOf(returned)
    }

    // StreetComplete is not supporting offsets, indexing by nth day of week etc
    // function may return identical or modified object or null
    // null or modified object indicates that original object was not representable in SC
    private fun reduceWeekDayRangeToSimpleDays(weekDayRange: WeekDayRange): WeekDayRange? {
        val returned = WeekDayRange()
        if (weekDayRange.startDay == null) {
            // invalid range
            return null
        }
        // returned.endDay may be null for range containing just a single day
        returned.endDay = weekDayRange.endDay
        returned.startDay = weekDayRange.startDay
        return returned
    }

    // StreetComplete supports solely date changing based on month
    // without any support for any other data ranges
    // function may return identical or modified object or null
    // null or modified object indicates that original object was not representable in SC
    private fun reduceDateRangeToFullMonths(dateRange: DateRange): DateRange? {
        for (date in arrayOf(dateRange.startDate, dateRange.endDate).filterNotNull()) {
            if (date.isOpenEnded) {
                return null //TODO: it may be supported by StreetComplete
            }
            if (date.weekDayOffset != null) {
                return null
            }
            if (date.dayOffset != 0) {
                return null
            }
        }
        val newDateRange = DateRange()

        val startDate = DateWithOffset()
        startDate.month = dateRange.startDate.month
        newDateRange.startDate = startDate

        if (dateRange.endDate != null) {
            // range with just single month will have endDate unset
            val endDate = DateWithOffset()
            endDate.month = dateRange.endDate.month
            newDateRange.endDate = endDate
        }
        return newDateRange
    }

    // StreetComplete has no support for times like "from sunrise to sunset"
    // this function throws away any info over "from hour X to hour Y"
    // function may return identical or modified object or null
    // null or modified object indicates that original object was not representable in SC
    private fun reduceTimeRangeToSimpleTime(timeSpan: TimeSpan): TimeSpan? {
        val simplifiedTimespan = TimeSpan()
        if (timeSpan.startEvent != null) {
            return null
        }
        if (timeSpan.endEvent != null) {
            return null
        }
        val startInMinutesSinceMidnight = timeSpan.start
        if (startInMinutesSinceMidnight < 0) {
            return null
        }
        if (startInMinutesSinceMidnight > 24 * 60) {
            return null
        }
        simplifiedTimespan.start = startInMinutesSinceMidnight
        val endInMinutesSinceMidnight = timeSpan.end
        if (endInMinutesSinceMidnight < 0) {
            return null
        }
        simplifiedTimespan.end = endInMinutesSinceMidnight
        return simplifiedTimespan
    }

    private fun emptyRule(): Rule {
        // workaround needed to construct empty Rule object
        // proposal to allow creation of Rule objects is at
        // https://github.com/simonpoole/OpeningHoursParser/pull/24
        val input = ByteArrayInputStream("".toByteArray())
        val parser = OpeningHoursParser(input)
        try {
            val rules = parser.rules(true)
            return rules(0)
        } catch (e: ParseException) {
            e.printStackTrace()
            throw RuntimeException()
        }
    }

}

WorkingAsssert.kt

The story of this file is a little embarrassing - I used to start assert and discovered later that it did not work. This should probably be eliminated before public relations, but I have no good idea of ​​replacement and the simple fact of removing assertions seems to be a bad idea for me.

package de.westnordost.streetcomplete.quests.opening_hours

object Assert {
    fun assert(conditionAssertedToBeTrue: Boolean) {
        if(!conditionAssertedToBeTrue) {
            throw AssertionError()
        }
    }
}
```

Vps In Europe [nl] Starting from only 5.35 USD | Full root access, managed support included!

VPSGet Its vision is to provide the best quality services with affordable prices for every customer.
We know how to cook virtual servers!

Our servers are located in Level III data centers in the Netherlands and Europe.
IP of test: 91.239.64.11. Test Download Files: 100 MB, 1 GB

VPS features:
Free managed support on request. *
• Additional discounts on quarterly, annual, or longer billing cycles.
• Full access to the root
• RAID-10 storage powered by SSD (gr8 performance for most use cases)
• Monthly VPS full backups on external storage included in all packages.
• 2x Xeon E5 processors per server node.
• Easy to use ClientArea: Manage your account and services from one place.
• SolusVM Control Panel: Separate access to manage only VPS services. + white label API reseller accounts available!
• TUN / TAP / PPP (you can use any VPN)
• 100 Mbps or more connection for each VPS (multiple uplinks on each node)
• Free IPv6
• 99.9% uptime guarantee
• 30-day money back guarantee
• Instant configuration
• A lot of Linux distributions to choose from. Custom operating system templates. OS templates on request.
• No contract
• 24×7 support (internal team)
• LiveChat (CET).
• Up to 30 IPv4 add-ons available through VPS for only $ 1 per IP for customers who have been using our services for more than 6 months.
Several payment methods available: Bitcoin, Paypal, Credit / debit cards, 2checkout, Webmoney / Paymentwall, Payza, BankWire.
We also accept Altcoins: Ethereum, Ethereum Classic, Litecoin, Dash, ZCash, Monero, Dogecoin, Decred, BitConnect, PeerCoin, Waves, ZenCash, Ripple. Additional discounts when paying with ETH or LTC, learn more

____________________________
VPS packages
10 additional IP addresses available for all packages!

VZ-1
$ 5.35 per month
1 processor core
512 MB of RAM
20Gb of storage space
100 Mbps connection
30-day money back guarantee
10 IPv6 included
1 IPv4 add-on module available
Basic managed support included
More info / Compare

VZ-2
$ 8.95 per month
1 processor core
1 GB of RAM
40 GB of disk space
100 Mbps connection
30-day money back guarantee
10 IPv6 included
5 additional IPv4 add-ons available
Basic managed support included
More info / Compare

VZ-3
$ 17.95 per month
2 processor cores
2 GB of RAM
60GB of storage space
100 Mbps connection
30-day money back guarantee
3 IPv4 included *New!
10 IPv6 included
10 additional IPv4 add-on modules available
Basic managed support included
More info / Compare

VZ-4
$ 35.9 per month
4 processor cores
4 GB of RAM
80Gb of storage space
100 Mbps connection
30-day money back guarantee
4 IPv4 included *New!
10 IPv6 included
10+ additional IPv4 add-ons available
Fully managed support included
More info / Compare

VZ-5
$ 71.95 per month
8 processor cores
8 GB of RAM
100 GB of disk space
300 Mbps connection
30-day money back guarantee
Premium Managed included (+ server monitoring on request)
5 IPv4 included *New!
10 IPv6 included
More than 25 additional IPv4 extensions available
More info / Compare

—————————-
We provide a many models (B) OS for customers (/ B). Some are available when ordering and others are in the reinstallation list. This list is updated from time to time.
We can also add the specified operating system model at the customer's request.

If you have any pre-sales questions, do not hesitate to contact our sales team!

VPS in Europe [NL] starting from only $ 5.35 | full root access, managed support included! | NewProxyLists

VPSGet Its vision is to provide the best quality services with affordable prices for every customer.
We know how to cook virtual servers!

Our servers are located in Level III data centers in the Netherlands and Europe.
IP of test: 91.239.64.11. Test Download Files: 100 MB, 1 GB

VPS features:
Free managed support on request. *
• Additional discounts on quarterly, annual, or longer billing cycles.
• Full access to the root
• RAID-10 storage powered by SSD (gr8 performance for most use cases)
• Monthly VPS full backups on external storage included in all packages.
• 2x Xeon E5 processors per server node.
• Easy to use ClientArea: Manage your account and services from one place.
• SolusVM Control Panel: Separate access to manage only VPS services. + white label API reseller accounts available!
• TUN / TAP / PPP (you can use any VPN)
• 100 Mbps or more connection for each VPS (multiple uplinks on each node)
• Free IPv6
• 99.9% uptime guarantee
• 30-day money back guarantee
• Instant configuration
• A lot of Linux distributions to choose from. Custom operating system templates. OS templates on request.
• No contract
• 24×7 support (internal team)
• LiveChat (CET).
• Up to 30 IPv4 add-ons available through VPS for only $ 1 per IP for customers who have been using our services for more than 6 months.
Several payment methods available: Bitcoin, Paypal, Credit / debit cards, 2checkout, Webmoney / Paymentwall, Payza, BankWire.
We also accept Altcoins: Ethereum, Ethereum Classic, Litecoin, Dash, ZCash, Monero, Dogecoin, Decred, BitConnect, PeerCoin, Waves, ZenCash, Ripple. Additional discounts when paying with ETH or LTC, learn more

____________________________
VPS packages
10 additional IP addresses available for all packages!

VZ-1
$ 5.35 per month
1 processor core
512 MB of RAM
20Gb of storage space
100 Mbps connection
30-day money back guarantee
10 IPv6 included
1 IPv4 add-on module available
Basic managed support included
More info / Compare

VZ-2
$ 8.95 per month
1 processor core
1 GB of RAM
40 GB of disk space
100 Mbps connection
30-day money back guarantee
10 IPv6 included
5 additional IPv4 add-ons available
Basic managed support included
More info / Compare

VZ-3
$ 17.95 per month

2 processor cores
2 GB of RAM
60GB of storage space
100 Mbps connection
30-day money back guarantee
3 IPv4 included *New!
10 IPv6 included
10 additional IPv4 add-on modules available
Basic managed support included
More info / Compare

VZ-4
$ 35.9 per month

4 processor cores
4 GB of RAM
80Gb of storage space
100 Mbps connection
30-day money back guarantee
4 IPv4 included *New!
10 IPv6 included
10+ additional IPv4 add-ons available
Fully managed support included
More info / Compare

VZ-5
$ 71.95 per month

8 processor cores
8 GB of RAM
100 GB of disk space
300 Mbps connection
30-day money back guarantee
Premium Managed included (+ server monitoring on request)
5 IPv4 included *New!
10 IPv6 included
More than 25 additional IPv4 extensions available
More info / Compare

—————————-
We provide a a lot of OS templates for the customers. Some are available when ordering and others are in the reinstallation list. This list is updated from time to time.
We can also add the specified operating system model at the customer's request.

If you have any pre-sales questions, do not hesitate to contact our sales team!

[WTS] VPS in Europe [NL] starting from only $ 5.35 | full root access, managed support included!

VPSGet Its vision is to provide the best quality services with affordable prices for every customer.
We know how to cook virtual servers!

Our servers are located in Level III data centers in the Netherlands and Europe.
IP of test: 91.239.64.11. Test Download Files: 100 MB, 1 GB

VPS features:

Free managed support on request. *
• Additional discounts on quarterly, annual, or longer billing cycles.
• Full access to the root
• RAID-10 storage powered by SSD (gr8 performance for most use cases)
• Monthly VPS full backups on external storage included in all packages.
• 2x Xeon E5 processors per server node.
• Easy to use ClientArea: Manage your account and services from one place.
• SolusVM Control Panel: Separate access to manage only VPS services. + white label API reseller accounts available!
• TUN / TAP / PPP (you can use any VPN)
• 100 Mbps or more connection for each VPS (multiple uplinks on each node)
• Free IPv6
• 99.9% uptime guarantee
• 30-day money back guarantee
• Instant configuration
• A lot of Linux distributions to choose from. Custom operating system templates. OS templates on request.
• No contract
• 24×7 support (internal team)
• LiveChat (CET).
• Up to 30 IPv4 add-ons available through VPS for only $ 1 per IP for customers who have been using our services for more than 6 months.
Several payment methods available: Bitcoin, Paypal, Credit / debit cards, 2checkout, Webmoney / Paymentwall, Payza, BankWire.
We also accept Altcoins: Ethereum, Ethereum Classic, Litecoin, Dash, ZCash, Monero, Dogecoin, Decred, BitConnect, PeerCoin, Waves, ZenCash, Ripple. Additional discounts when paying with ETH or LTC, learn more

____________________________
VPS packages

10 additional IP addresses available for all packages!

VZ-1
$ 5.35 per month
1 processor core
512 MB of RAM
20Gb of storage space
100 Mbps connection
30-day money back guarantee
10 IPv6 included
1 IPv4 add-on module available
Basic managed support included
More info / Compare

VZ-2
$ 8.95 per month

1 processor core
1 GB of RAM
40 GB of disk space
100 Mbps connection
30-day money back guarantee
10 IPv6 included
5 additional IPv4 add-ons available
Basic managed support included
More info / Compare

VZ-3
$ 17.95 per month

2 processor cores
2 GB of RAM
60GB of storage space
100 Mbps connection
30-day money back guarantee
3 IPv4 included *New!

10 IPv6 included
10 additional IPv4 add-on modules available
Basic managed support included
More info / Compare

VZ-4
$ 35.9 per month

4 processor cores
4 GB of RAM
80Gb of storage space
100 Mbps connection
30-day money back guarantee
4 IPv4 included *New!

10 IPv6 included
10+ additional IPv4 add-ons available
Fully managed support included
More info / Compare

VZ-5
$ 71.95 per month

8 processor cores
8 GB of RAM
100 GB of disk space
300 Mbps connection
30-day money back guarantee
Premium Managed included (+ server monitoring on request)
5 IPv4 included *New!

10 IPv6 included
More than 25 additional IPv4 extensions available
More info / Compare

—————————-
We provide a a lot of OS templates for the customers. Some are available when ordering and others are in the reinstallation list. This list is updated from time to time.
We can also add the specified operating system model at the customer's request.

If you have any pre-sales questions, do not hesitate to contact our sales team!

. (tagsToTranslate) forum for webmasters (t) internet marketing (t) search engine optimization (t) web design (t) seo (t) ppc (t) affiliate marketing (t) marketing for search engines (t) ) web site hosting (t) name (t) social media

How to represent, with the help of a Venn diagram: the complement of A is included in B?

It seems easy to represent:

  • A is included in B

and

  • A is included in the complement of B.

But I do not find a way to represent: the complement of A is included in B.

Sale – Canspace Protected DDoS Hosting – cPanel and WHM included – Canada! | Promotion Forum

Entrust your website to the leading provider of web hosting in Canada

CanSpace Solutions is the leading provider of hosting services in Canada. Our VPS plans are 100% Canadian, and fully managed solutions – We take care of the administration of your server so that you can focus on your business. CanSpace Solutions is a Certified by CIRA supplier – certified annually by the Government of Canadaand we are in the hosting business for more than 10 years. Our head office is located here in Canada. Our data centers, as well as all our servers, are located in Canada. All of our employees are here in Canada and we only charge in Canadian dollars. We are the Canadian leader domain registrar .ca. Canada's largest companies and organizations trust us. In case you have not guessed it yet, CanSpace is a very proud Canadian company – just like yours.

Check-out Canspace.ca Canadian VPS Hosting Entirely managed packages:

Start-up hosting plan
5 GB of secure storage space on disk
Monthly bandwidth of 15 GB
5 domains supported
Free SSL Certificate Let's Encrypt
5 MySQL databases
Price – $ 4.99 / month [ORDER NOW]

Average accommodation plan
50 GB of secure disk storage
Unlimited monthly bandwidth
Unlimited number of domains supported
Free SSL Certificate Comodo
MySQL / Unlimited mailboxes
Price – $ 9.99 / month [ORDER NOW]

Professional accommodation plan
200 GB of secure storage space on disk
Unlimited monthly bandwidth
Unlimited number of domains supported
Free SSL Certificate Comodo
MySQL / Unlimited mailboxes
Price – $ 22.99 / month [ORDER NOW]

Buy any of our packages on annual terms and get your free first year domain registration / transfer!

Our web hosting guarantees:
1] 24/7/365 Support – Our support team is available 24 hours a day, 7 days a week, to help you solve all your problems. In fact, we strive to respond to all tickets within 10 minutes, even on weekends and holidays. When you choose CanSpace as a web hosting provider, you opt for high-end web hosting and peace of mind.
2] Safe, secure, reliable – Downtime related to web hosting can cause customers to lose confidence in your business and cost you money. Choosing a provider simply based on cost can be an absolute nightmare: data loss, inactive sites for days and non-existent assistance. The largest Canadian companies have trusted CanSpace for years for its high-end and reliable web hosting offering.
3] 30 days warranty – When you choose CanSpace for the web hosting needs of your business, you opt for security, professionalism and peace of mind. We are so convinced that you will be satisfied with our web hosting services that we will refund your money if you are not! All of our standard web hosting packages are covered by our 30-day money back guarantee, without risk.
4] No overselling – Unlike our competitors, we do not offer unrealistic web hosting plans with "unlimited disk space and bandwidth for $ 1 per month", resulting in slow loading and often websites. inaccessible. You'll always get the level of web hosting and reliability that Canadians expect from CanSpace.
5] We value your business – We understand that your website is the key to your business and we strive to make it work properly, quickly and reliably. Our data centers are open 24 hours a day, 7 days a week, and our support staff is available 24 hours a day to answer your concerns or problems.
6] Daily backups – All web hosting accounts are backed up daily. There is always a method of recovery in case of emergency. Unlike other providers, we give our customers full access to their backups. So even in the case of simple human error, old data can be restored in just a few clicks!

We understand that hosting is about providing superior service, support and reliability – and that you want to offer the same to your customers. We treat all our customers with the same level of service and professionalism, whether they are small startups or large companies. We are always happy to hear from you! AT CanSpace We are proud of our superior customer support. Our goal is to respond to all requests within half an hour, even though most of them are processed in less than 10 minutes.

Existing customers can submit a Support ticket via our customer area. Our support technicians are available 24 hours a day, 7 days a week. We strongly encourage existing customers to use our ticket system so that we can track your problem correctly.

SUCH: 1-888-99-DOT-CA
E-mail: info@canspace.ca
Like us on facebook

Should exceptions be included in the UML sequence diagram?

If the exceptions raised in case of error are represented in the UML sequence diagram, would the UML sequence diagram be too heavy?

If they are not represented, how to talk about it?