text:
import { sortBy } from 'lodash';

import { urlUtil, UrlQueryMap, Labels, DataSourceInstanceSettings } from '@grafana/data';
import { config } from '@grafana/runtime';
import { alertInstanceKey } from 'app/features/alerting/unified/utils/rules';
import { SortOrder } from 'app/plugins/panel/alertlist/types';
import { Alert, CombinedRule, FilterState, RulesSource, SilenceFilterState } from 'app/types/unified-alerting';
import {
  GrafanaAlertState,
  PromAlertingRuleState,
  mapStateWithReasonToBaseState,
} from 'app/types/unified-alerting-dto';

import { ALERTMANAGER_NAME_QUERY_KEY } from './constants';
import { getRulesSourceName } from './datasource';
import { getMatcherQueryParams } from './matchers';
import * as ruleId from './rule-id';

export function createViewLink(ruleSource: RulesSource, rule: CombinedRule, returnTo: string): string {
  const sourceName = getRulesSourceName(ruleSource);
  const identifier = ruleId.fromCombinedRule(sourceName, rule);
  const paramId = encodeURIComponent(ruleId.stringifyIdentifier(identifier));
  const paramSource = encodeURIComponent(sourceName);

  return urlUtil.renderUrl(`${config.appSubUrl}/alerting/${paramSource}/${paramId}/view`, { returnTo });
}

export function createExploreLink(dataSourceName: string, query: string) {
  return urlUtil.renderUrl(`${config.appSubUrl}/explore`, {
    left: JSON.stringify([
      'now-1h',
      'now',
      dataSourceName,
      { datasource: dataSourceName, expr: query },
      { ui: [true, true, true, 'none'] },
    ]),
  });
}

export function arrayToRecord(items: Array<{ key: string; value: string }>): Record<string, string> {
  return items.reduce<Record<string, string>>((rec, { key, value }) => {
    rec[key] = value;
    return rec;
  }, {});
}

export const getFiltersFromUrlParams = (queryParams: UrlQueryMap): FilterState => {
  const queryString = queryParams['queryString'] === undefined ? undefined : String(queryParams['queryString']);
  const alertState = queryParams['alertState'] === undefined ? undefined : String(queryParams['alertState']);
  const dataSource = queryParams['dataSource'] === undefined ? undefined : String(queryParams['dataSource']);
  const ruleType = queryParams['ruleType'] === undefined ? undefined : String(queryParams['ruleType']);
  const groupBy = queryParams['groupBy'] === undefined ? undefined : String(queryParams['groupBy']).split(',');
  return { queryString, alertState, dataSource, groupBy, ruleType };
};

export const getNotificationPoliciesFilters = (searchParams: URLSearchParams) => {
  return {
    queryString: searchParams.get('queryString') ?? undefined,
    contactPoint: searchParams.get('contactPoint') ?? undefined,
  };
};

export const getSilenceFiltersFromUrlParams = (queryParams: UrlQueryMap): SilenceFilterState => {
  const queryString = queryParams['queryString'] === undefined ? undefined : String(queryParams['queryString']);
  const silenceState = queryParams['silenceState'] === undefined ? undefined : String(queryParams['silenceState']);

  return { queryString, silenceState };
};

export function recordToArray(record: Record<string, string>): Array<{ key: string; value: string }> {
  return Object.entries(record).map(([key, value]) => ({ key, value }));
}

export function makeAMLink(path: string, alertManagerName?: string, options?: Record<string, string>): string {
  const search = new URLSearchParams(options);
  if (alertManagerName) {
    search.append(ALERTMANAGER_NAME_QUERY_KEY, alertManagerName);
  }
  return `${path}?${search.toString()}`;
}

export function makeRuleBasedSilenceLink(alertManagerSourceName: string, rule: CombinedRule) {
  const labels: Labels = {
    alertname: rule.name,
    ...rule.labels,
  };

  return makeLabelBasedSilenceLink(alertManagerSourceName, labels);
}

export function makeLabelBasedSilenceLink(alertManagerSourceName: string, labels: Labels) {
  const silenceUrlParams = new URLSearchParams();
  silenceUrlParams.append('alertmanager', alertManagerSourceName);

  const matcherParams = getMatcherQueryParams(labels);
  matcherParams.forEach((value, key) => silenceUrlParams.append(key, value));

  return `${config.appSubUrl}/alerting/silence/new?${silenceUrlParams.toString()}`;
}

export function makeDataSourceLink<T>(dataSource: DataSourceInstanceSettings<T>) {
  return `${config.appSubUrl}/datasources/edit/${dataSource.uid}`;
}

// keep retrying fn if it's error passes shouldRetry(error) and timeout has not elapsed yet
export function retryWhile<T, E = Error>(
  fn: () => Promise<T>,
  shouldRetry: (e: E) => boolean,
  timeout: number, // milliseconds, how long to keep retrying
  pause = 1000 // milliseconds, pause between retries
): Promise<T> {
  const start = new Date().getTime();
  const makeAttempt = (): Promise<T> =>
    fn().catch((e) => {
      if (shouldRetry(e) && new Date().getTime() - start < timeout) {
        return new Promise((resolve) => setTimeout(resolve, pause)).then(makeAttempt);
      }
      throw e;
    });
  return makeAttempt();
}

const alertStateSortScore = {
  [GrafanaAlertState.Alerting]: 1,
  [PromAlertingRuleState.Firing]: 1,
  [GrafanaAlertState.Error]: 1,
  [GrafanaAlertState.Pending]: 2,
  [PromAlertingRuleState.Pending]: 2,
  [PromAlertingRuleState.Inactive]: 2,
  [GrafanaAlertState.NoData]: 3,
  [GrafanaAlertState.Normal]: 4,
};

export function sortAlerts(sortOrder: SortOrder, alerts: Alert[]): Alert[] {
  // Make sure to handle tie-breaks because API returns alert instances in random order every time
  if (sortOrder === SortOrder.Importance) {
    return sortBy(alerts, (alert) => [
      alertStateSortScore[mapStateWithReasonToBaseState(alert.state)],
      alertInstanceKey(alert).toLocaleLowerCase(),
    ]);
  } else if (sortOrder === SortOrder.TimeAsc) {
    return sortBy(alerts, (alert) => [
      new Date(alert.activeAt) || new Date(),
      alertInstanceKey(alert).toLocaleLowerCase(),
    ]);
  } else if (sortOrder === SortOrder.TimeDesc) {
    return sortBy(alerts, (alert) => [
      new Date(alert.activeAt) || new Date(),
      alertInstanceKey(alert).toLocaleLowerCase(),
    ]).reverse();
  }
  const result = sortBy(alerts, (alert) => alertInstanceKey(alert).toLocaleLowerCase());
  if (sortOrder === SortOrder.AlphaDesc) {
    result.reverse();
  }

  return result;
}


text:
package me.dribba.components

import com.pi4j.io.gpio.{PinState, GpioPinDigitalOutput}

class PumpComponentLike(pin: GpioPinDigitalOutput) extends PumpComponent {

  // Always make sure the pump will turn off when the app dies
  pin.setShutdownOptions(true, PinState.LOW)

  override def off(): Unit = pin.low()

  override def on(): Unit = pin.high()
}

redpajama_set_name: RedPajamaGithub


text:
module.exports = {
    lang: {
        de: `de`
    },
    exercise: {
        info: `Sie können nun diese Tipps im Recherchecafé ausprobieren. Aber Achtung! Im Recherchecafé bekommen Sie nur das, was Sie bestellen. Das ist nicht immer das, was Sie auch wünschen und manchmal bekommen Sie vielleicht auch gar nichts.`,
        shortInfo: `Sie können nun diese Tipps im Recherchecafé ausprobieren.`,
        submit: `Bestellen`,
        reset: `Zurücksetzen`,
        next: `Weiter!`,
        correct: `Richtig!`,
        wrong: `Falsch!`,
        retry: `Nochmal!`,
        pleaseOrder: `Bitte markieren Sie alles, was Sie bekommen.`,
        drinks: {
            cafeAuLait: {
                title: `Café au Lait`,
                desc: `Kaffee mit Milch in einer Boule, Zucker separat`,
                keywords: `Kaffee, Milch, Schale, Zucker`
            },
            Einspänner: {
                title: `Einspänner`,
                desc: `Doppelmokka im Glas mit Schlagobershaube und Hohlhippe`,
                keywords: `Glas, Mokka, Schlagsahne, Waffel`
            },
            Eiskaffee: {
                title: `Eiskaffee englisch`,
                desc: `ein Drittel Kaffee, ein Drittel Eis, ein Drittel Obers`,
                keywords: `Eis, Glas, Kaffee, Schlagsahne`
            },
            Fiaker: {
                title: `Fiaker`,
                desc: `Doppelmokka im Henkelglas mit einem Schuss Kirschwasser gespritzt, mit Schlagobershaube und Cocktailkirsche`,
                keywords: `Cocktailkirsche, Glas, Kirschwasser, Mokka, Schlagsahne`
            },
            Franziskaner: {
                title: `Franziskaner`,
                desc: `leichte Melange mit Schlagobers und Schokostreuseln`,
                keywords: `Glas, Kaffee, Milch, Schlagsahne, Schokolade`
            },
            Häferlkaffee: {
                title: `Häferlkaffee`,
                desc: `Großer Brauner (doppelter Mokka mit Kaffeeobers) im Häferl statt in der großen Schale`,
                keywords: `Becher, Kaffeesahne, Mokka`
            },
            Kännchen: {
                title: `Kännchen Kaffee`,
                desc: `Kaffee im Kännchen (ca. 2 Tassen), separat Kaffeesahne und Zucker`,
                keywords: `Kaffee, Kaffeesahne, Kaffeekanne, Tasse, Zucker`
            },
            Kleiner: {
                title: `Kleiner Brauner`,
                desc: `einfacher Mokka mit Milch oder Obers in kleiner Schale`,
                keywords: `Kaffeesahne, Mokka, Tasse`
            },
            Latte: {
                title: `Latte Macchiato`,
                desc: `"gefleckte Milch", aufgeschäumte warme Milch mit Espresso`,
                keywords: `Espresso, Glas, Milch`
            },
            Maria: {
                title: `Maria Theresia`,
                desc: `ein großer Mokka mit einem Schuss Orangenlikör, Schlagobershaube und verziert mit Orangenzesten`,
                keywords: `Apfelsinenschale, Glas, Mokka, Orangenlikör, Schlagsahne`
            },
            Melange: {
                title: `Melange`,
                desc: `halb Kaffee, halb heiße geschäumte Milch, mit Milchschaumhäubchen`,
                keywords: `Glas, Kaffee, Milch`
            },
            Milchkaffee: {
                title: `Milchkaffee`,
                desc: `Kaffee mit Milch(-Schaum)`
            },
            Pharisäer: {
                title: `Pharisäer`,
                desc: `schwarzer Kaffee mit Rum und einer Haube Schlagsahne überdeckt mit Schokoraspeln auf der Sahne serviert`,
                keywords: `Becher, Kaffee, Rum, Schlagsahne, Schokolade`
            },
            Rüdesheimer: {
                title: `Rüdesheimer Kaffee`,
                desc: `Kaffee mit Weinbrand flambiert, mit einem Schlag Sahne, Vanillezucker und Schokoladestreusel`,
                keywords: `Glas, Kaffee, Schlagsahne, Schokolade, Vanillezucker, Weinbrand`
            },
            TürkKahvesi: {
                title: `Türk Kahvesi`,
                desc: `feinst gemahlener Kaffee, mit Zucker im Kupferkännchen aufgekocht`,
                keywords: `Kaffee, Kupferkanne, Tasse, Zucker`
            },
            Verkehrter: {
                title: `Verkehrter`,
                desc: `Kaffee mit 2/3 Milch und 1/3 Kaffee`
            },
            Verlängerter: {
                title: `Verlängerter`,
                desc: `die Dosierung eines kleinen Schwarzen wird mit der Wassermenge eines großen Schwarzen zubereitet`
            },
            Wiener: {
                title: `Wiener Eiskaffee`,
                desc: `köstliches Vanilleeis, doppelter Mokka, Schlagobershaube, Kaffeebohne und Hohlhippe`,
                keywords: `Glas, Kaffeebohne, Mokka, Schlagsahne, Vanilleeis, Waffel`
            }
        }
    },
    page: [
        { //page1
            headline: `Lernziele`,
            intro: `Dieses Grundlagenmodul wird Sie unterstützen, erfolgreicher nach Literatur für Ihr Studium zu recherchieren.`,
            principles: `Dabei geht es um folgende Prinzipien und Techniken einer Recherche:`,
            content: [
                `formale oder inhaltliche Recherchen`,
                `Trunkieren`,
                `Verknüpfen`,
                `Phrase`,
                `Schlagwort`,
                `Klassifikation`
            ],
            rechercheCafeIntro: `Lesen Sie zunächst die Erläuterungen zu jedem Thema. Im Anschluss können Sie die Tipps gleich im Recherchecafé* ausprobieren. Aber Achtung! Im Recherchecafé* bekommen Sie nur das, was Sie bestellen, und das ist nicht immer das, was Sie auch wünschen.`,
            rechercheCafeIdee: `* Das Recherchecafé wurde von der Idee des Boole\`schen Restaurants inspiriert, vgl. Donald A. Barclay: Teaching the standard features of electronic databases. In: Teaching electronic information literacy : a how-to-do-it manual / ed. by Donald A. Barclay. New York: Neal-Schuman, 1995. S. 65 sowie Detlev Bieler, Thomas Hapke, Oliver Marahrens, TUB Hamburg-Harburg: DISCUS`
        },
        { //page2
            headline: `Formale, inhaltliche und feldbezogene Suche`,
            formalVsContent: `Zu Beginn Ihrer Recherche sollten Sie sich verdeutlichen, ob Sie formal oder inhaltlich (sachlich, thematisch) suchen:`,
            formalHeader: `Formale Suche`,
            formalExplanation: `Bei einer formalen Suche haben Sie (mehr oder weniger vollständige) Angaben einer Quelle, z.B. aus einer Literaturliste oder durch den Tipp eines Professors. Die genaue Eingabe dieser Angaben führt schnell zu einem Nachweis, ob diese Quelle für Sie verfügbar ist. Die meisten Ressourcen tolerieren allerdings keine Tippfehler.`,
            contentHeader: `Inhaltliche Suche`,
            contentExplanation: `Bei einer inhaltlichen Suche kennen Sie die Quelle nicht genau und wissen nicht, ob Sie die richtigen Suchbegriffe gewählt haben, ob es überhaupt Quellen zu dem gesuchten Thema gibt, und wenn ja, wie viele.`,
            fieldHeader: `Feldbezogene Suche`,
            FieldContent: `Die meisten Ressourcen bieten neben der Freitextsuche in allen Feldern - zumindest in der Option "erweiterte Suche" - eine feldbezogene Suche an. In der formalen Suche ist die Nutzung des Feldes "Autor" vorteilhaft, wenn der Autorenname auch ein Titelstichwort sein kann. In der inhaltlichen Suche ist die Nutzung der Felder "Schlagwort" und "Klassifikation" vorteilhaft. Dazu mehr in späteren Abschnitten.`,
            nextPage: `Auf der folgenden Seite finden Sie Beispiele für formale Suchen.`
        },
        { //page3
            headline: `Beispiele - Formale Suche`,
            intro: `1. In einer Literaturliste finden Sie die Angaben "Nicholas Gregory Mankiw: Grundzüge der Volkswirtschaftslehre. 4. Aufl. Schäffer-Poeschel, 2008": Im Bibliothekskatalog finden Sie das gewünschte Buch wenn Sie im Feld Alle Wörter jedes beliebige Stichwort aus diesen Angaben eingeben, z.B.`,
            introExamples: [
                `Mankiw, Nicholas Gregory`,
                `Volkswirtschaftslehre Nicholas`,
                `volkswirtschaftslehre grundzüge`
            ],
            professorRecommendation: `2. Ihr Professor empfiehlt Ihnen in Fragen des bibliothekarischen Grundwissens (z.B. Was ist ein Stichwort?) im "Hacker" nachzuschlagen: Wenn Sie nun im Bibliothekskatalog Hacker über das Feld Alle Wörter suchen, werden Sie viele Treffer erzielen, die nichts mit der gesuchten Person zu tun haben, sondern mit IT-Spezialisten.`,
            authorHacker: `Wenn Sie hingegen im Feld "Person, Autor" den Suchbegriff "Hacker" eingeben, finden Sie nur Bücher, deren Autor ein Mensch namens Hacker ist. – Übrigens: Die meisten Ressourcen verlangen im Feld Autor die Ansetzung "Nachname, Vorname", also`,
            authorHackerExamples: [
                `Mankiw, Nicholas`,
                `Hacker, Rupert`
            ],
            or: `oder`,
            outro: `Prüfen Sie in den Hilfetexten der jeweiligen Ressource, wie Namen angesetzt werden.`
        },
        { //page4
            headline: `Übung - formale Suche 1`,
            explanation: `Da Sie formale Angaben kennen, machen Sie eine formale Suche und bestellen mit der Eingabe <span class="searchPhrase">pharisäer</span>.`,
            wrong: `Ein bisschen mehr Ernsthaftigkeit, bitte!<br/>Es wird gleich schwieriger.<br/>Genau eine Antwort ist richtig.`
        },
        { //page5
            headline: `Übung - formale Suche 2`,
            explanation: `Sie bekommen von einem Kommilitonen mündlich den Hinweis auf eine italienische Kaffespezialität und bestellen mit der Eingabe <span class="searchPhrase">latte macciato</span>.`,
            correct: `Genau! Sie bekommen nichts aus der Liste.<br/>Bei der Suche kommt es darauf an, dass die Wörter korrekt geschrieben sind.`,
            wrong: `Schauen Sie nochmal genau nach. Denken Sie daran, dass es bei der Suche wichtig ist, dass alle Wörter korrekt geschrieben sind. Und denken Sie daran, manchmal ist auch keine der Antworten richtig.`
        },
        {//page6
            headline: `Trunkieren`,
            intro: `Das Trunkierungszeichen (auch Wildcard-Operator, Joker oder Platzhalter genannt) ersetzt bei der Suchanfrage`,
            introList: [
                `einen Buchstaben`,
                `keinen bis zu einer beliebigen Anzahl von Buchstaben`
            ],
            or: `oder`,
            asterisk: `In den meisten Ressourcen wird das Sternchen (Asterisk, *) verwendet, in anderen !, ?, $ oder #. Prüfen Sie in jeder Ressource in den Hilfetexten, welches Zeichen für welche Abkürzung verwendet wird.`,
            rightTruncation: `In den meisten Ressourcen ist die Rechts- oder Endtrunkierung möglich, in einigen zusätzlich die Links- oder Anfangstrunkierung.`,
            examples: `Beispiele`,
            exampleSearchQuestionmarkIntro: `Sie geben in eine Ressource <span class="searchPhrase">me?er</span> ein und erhalten Treffer, in denen folgende Worte vorkommen:`,
            exampleSearchQuestionmarkList: [
                `Meier`,
                `Meyer`,
                `Meter`
            ],
            andAlso: `aber auch`,
            truncationQuestionmarkSummary: `Im Hilfetext steht: Das Trunkierungszeichen ? ersetzt einen Buchstaben`,
            exampleSearchAsteriskIntro: `Sie geben in einer Ressource <span class="searchPhrase">wirtschaft*</span> ein und erhalten Treffer, in denen z.B. folgende Worte vorkommen, z.B.`,
            exampleSearchAsteriskList: [
                'Wirtschaft',
                'Wirtschafts-',
                'Wirtschaftrecht'
            ],
            exampleSearchDoubleAsteriskIntro: `Sie geben in einer Ressource <span class="searchPhrase">*wirtschaft*</span> ein und erhalten zusätzlich Treffer, in denen z.B. folgende Worte vorkommen:`,
            exampleSearchDoubleAsteriskList: [
                'Betriebswirtschaftslehre',
                'Hauswirtschaftlerin'
            ],
            truncationAsteriskSummary: `Im Hilfetext steht: Das Trunkierungszeichen * ersetzt keinen bis zu einer beliebigen Anzahl von Buchstaben vor und/oder nach dem von Ihnen eingegebenen Wort.`,
            outro: `Wenn Sie Suchbegriffe trunkieren, erhalten Sie eine größere Treffermenge, als wenn Sie das nicht tun.`
        },
        { //page7
            headline: `Übung`,
            explanation: `Sie wünschen Kaffee mit Schlagsahne oder Schlagobers und bestellen mit der Eingabe schlag*.
Das * ersetzt eine beliebige Anzahl von Buchstaben am Ende des Suchbegriffs.`,
            wrong: `Das war noch nicht ganz korrekt. Kleiner Tipp: Insgesamt bekommen Sie mit der Eingabe <span class="searchPhrase">schlag*</span> 7 Spezialitäten von unserer Karte.`
        },
        { //page8
            headline: `Verknüpfen`,
            intro: `Eine Form der Verknüpfung kennen Sie aus dem Umgang mit Suchmaschinen: Wenn Sie mehrere Suchbegriffe, durch Leerzeichen voneinander getrennt, hintereinander schreiben, erhalten Sie Treffer, in denen alle Suchbegriffe vorkommen, unabhängig von der Reihenfolge und den Zusammenhängen. In manchen Ressourcen werden diese Verknüpfungs-Operatoren durch Zeichen oder Wörter dargestellt, in manchen durch Felder zum Anklicken.`,
            importantOperators: `Nachfolgend finden Sie die wichtigsten Verknüpfungsoperatoren und Beispiele.`,
            andOperators: {
                headline: '1. Leerzeichen, +, UND, und, AND, and',
                explanation: `Dieser Verknüpfungsoperator findet alle Treffer, in denen alle verknüpften Suchbegriffe vorkommen.`,
                exampleHeadline: `Beispiel`,
                exampleIntro: `Die Eingabe <span class="searchPhrase">mankiw UND volkswirtschaftslehre</span> findet`,
                exampleResult: [
                    `Mankiw: Grundzüge der Volkswirtschaftslehre`
                ]
            },
            orOperators: {
                headline: `2. /, ODER, oder, OR, or`,
                explanation: `Dieser Verknüpfungsoperator findet alle Treffer, in denen mindestens ein Suchbegriff vorkommt.`,
                attention: `Achtung!`,
                attentionText: `Anders als im normalen Sprachgebrauch handelt es sich hier nicht um ein exklusives ODER ("Christin oder Jakob machen den Abwasch"), sondern um ein inklusives ODER ("Christin oder Jakob oder beide …")!`,
                exampleHeadline: `Beispiel`,
                exampleIntro: `Die Eingabe <span class="searchPhrase">mankiw ODER volkswirtschaftslehre</span> findet`,
                exampleResult: [
                    `Mankiw: Makroökonomik – mit vielen Fallbeispielen`,
                    `Ending: Volkswirtschaftslehre – schnell erfasst`,
                    `Mankiw: Grundzüge der Volkswirtschaftslehre`
                ]
            },
            notOperators: {
                headline: `3. -, NICHT, nicht, NOT, not`,
                explanation: `Dieser Verknüpfungsoperator findet alle Treffer, in denen der markierte Suchbegriff nicht vorkommt.`,
                attention: `Vorsicht!`,
                attentionText: `Sie schließen dabei möglicherweise interessante Treffer aus, weil zufällig der Suchbegriff in ihm vorkommt!`,
                example: `Beispiel`,
                exampleIntro: `Die Eingabe <span class="searchPhrase">volkswirtschaftslehre NICHT mankiw</span> findet`,
                exampleResult: [
                    `Ending: Volkswirtschaftslehre – schnell erfasst`
                ]
            },
            nearOperators: {
                headline: `4. NEAR, Within, Adj(acent)`,
                explanation: `Dieser Verknüpfungsoperator legt die maximalen Abstände zwischen den Suchbegriffen und eventuell ihre Reihenfolge fest. Siehe Hilfetexte der Ressourcen!`,
                example: `Beispiel`,
                exampleIntro: `Die Eingabe <span class="searchPhrase">gesellschaft w/2 medien</span> (w/2 bedeutet, dass nicht mehr als 2 Worte zwischen den Suchbegriffen liegen) findet:`,
                exampleResult: [
                    `Müller: Gesellschaft und Medien`,
                    `Ziemann: Medien der Gesellschaft – Gesellschaft der Medien`,
                    `Kamps: Die offene Gesellschaft und ihre Medien`
                ]
            }
        },
        { //page9
            headline: `Verknüpfen mit unterschiedlichen Operatoren`,
            exampleHeadline: `Beispiele`,
            preCombination: {
                explanation: `Wollen Sie mehr als zwei Suchbegriffe mit unterschiedlichen Operatoren verknüpfen, so müssen Sie Klammern setzen, um deutlich zu machen, in welcher Reihenfolge die Verknüpfungen abgearbeitet werden sollen.`,
                exampleResult: [
                    `(qualitätsmanagement ODER qm) UND sozial*`,
                    `(qualitätsmanagement ODER qm) UND ("soziale arbeit" ODER sozialarbeit)`
                ],
                exampleExplanation: `Damit haben Sie die Suche präkombiniert, d.h. Sie haben die Suche vor der Abfrage vollständig formuliert.`,
            },
            postCombination: {
                explanation: `Eine andere Methode ist die Postkoordination: Dabei führen Sie die Abfragen nacheinander einzeln durch, rufen die Suchgeschichte auf und koordinieren die Ergebnisse im Nachhinein. Manchmal ist es günstiger, die Treffermengen nach und nach einzuschränken.`,
                exampleIntro: `Sie führen nacheinander die Suche nach den folgenden Begriffen durch:`,
                exampleResult: [
                    `qualitätsmanagement => Ergebnis 1`,
                    `qm => Ergebnis 2`,
                    `"soziale arbeit" => Ergebnis 3`,
                    `Sozialarbeit => Ergebnis 4`
                ],
                exampleExplanation: `Sie rufen die Suchgeschichte auf und koordinieren diese vier Ergebnisse im Nachhinein:`,
                exampleCombinationResult: [
                    `Ergebnis 1 ODER Ergebnis 2 => Ergebnis 5`,
                    `Ergebnis 3 ODER Ergebnis 4 => Ergebnis 6`
                ],
                exampleFinalCombination: `Nun koordinieren Sie auch noch die Ergebnisse der Suchen 5 und 6:`,
                exampleFinalCombinationResult: [
                    `Ergebnis 5 UND Ergebnis 6 = Ergebnis 7`
                ],
                exampleOutro: `Das Ergebnis der postkoordinierten Suche ist dasselbe wie das Ergebnis der 2. präkombinierten Suche.`
            }
        },
        { //page10
            headline: `Übung - UND`,
            explanation: `Sie wünschen Kaffee mit Sahne und bestellen mit der Eingabe <span class="searchPhrase">kaffee UND sahne</span>.`,
            wrong: `Das war noch nicht ganz korrekt. Kleiner Tipp: Insgesamt bekommen Sie mit der Eingabe <span class="searchPhrase">kaffee UND sahne</span> 2 Spezialitäten von unserer Karte.`
        },
        { //page11
            headline: `Übung - ODER`,
            explanation: `Sie wünschen Kaffee mit Schlagsahne oder Schlagobers<br/> und bestellen mit der Eingabe <span class="searchPhrase">schlagsahne ODER schlagobers</span>.`,
            wrong: `Das war noch nicht ganz korrekt. Kleiner Tipp: Insgesamt bekommen Sie mit der Eingabe schlagsahne ODER schlagobers 2 Spezialitäten von unserer Karte.`

        },
        { //page12
            headline: `Übung - Präkombination 1`,
            explanation: `Sie wünschen Kaffee oder Mokka mit Sahne oder Obers. Sie formulieren Ihren Wunsch vollständig vor der Bestellung und bestellen mit der Eingabe (kaffee ODER mokka) UND (sahne ODER obers).`,
            wrong: `Das war noch nicht ganz korrekt. Kleiner Tipp: Insgesamt bekommen Sie mit der Eingabe "(kaffee ODER mokka) UND (sahne ODER obers)" 4 Spezialitäten von unserer Karte.`
        },
        { //page13
            headline: `Übung - Präkombination 2`,
            explanation: `Sie wünschen Kaffee oder Mokka mit Sahne oder Obers. Sie formulieren Ihren Wunsch vollständig vor der Bestellung und bestellen mit der Eingabe (*kaffee* ODER *mokka*) UND (*sahne* ODER *obers*). Aber Achtung: Bei dieser Bestellung ändert sich das Ergebnis durch die Sternchen in Ihrer Eingabe!`,
            allDone: `Sie wollten Kaffee oder Mokka mit Sahne oder Obers bestellen. Wenn Sie nun die Postkoordination durchführen, erhalten Sie die richtige Bestellung. Es sind die Getränke bestellen, bei denen in beiden Spalten die Häkchen aktiviert sind.`,
            wrong: `Das war noch nicht ganz korrekt. Kleiner Tipp: Insgesamt bekommen Sie mit der Eingabe "(*kaffee* ODER *mokka*) UND (*sahne* ODER *obers*)" 10 Spezialitäten von unserer Karte.`
        },
        { //page14
            headline: `Übung - Postkoordination`,
            intro: `Sie können nun diese Tipps im Recherchecafé ausprobieren. Aber Achtung! Im Recherchecafé bekommen Sie nur das, was Sie bestellen. Das ist nicht immer das, was Sie auch wünschen und manchmal bekommen Sie vielleicht auch gar nichts.`,
            allDone: `Mit dieser nachträglichen Koordination der Suchbegriffe haben Sie dasselbe Ergebnis erzielt wie mit der präkombinierten Suche (kaffee ODER mokka) UND (sahne ODER obers).`,
            explanation: `Sie erinnern sich: Bei der Postkoordination führen Sie die einzelnen Suchen nacheinander aus und schränken die Treffermenge dann nach und nach ein. Sie wünschen Kaffee oder Mokka mit Sahne oder Obers.`,
            tasks: [
                {
                    task: `Sie bestellen zunächst mit der Eingabe <span class="searchPhrase">kaffee</span>.`,
                    wrong: `Das war noch nicht ganz korrekt. Kleiner Tipp: Insgesamt bekommen Sie in diesem Schritt für die Eingabe von kaffee 9 Spezialitäten von unserer Karte.`,
                    correct: `Richtig! Führen Sie nun die nächste Eingabe aus.`
                }, {
                    task: `Im nächsten Schritt Ihrer Bestellung markieren Sie nun zusätzlich alles, was Sie mit der Eingabe <span class="searchPhrase">mokka</span> bekommen.`,
                    wrong: `Das war noch nicht ganz korrekt. Kleiner Tipp: Insgesamt bekommen Sie in diesem Schritt für die zusätzliche Eingabe von mokka 4 zusätzliche Spezialitäten von unserer Karte.`,
                    correct: `Richtig! Führen Sie nun die nächste Eingabe aus.`
                }, {
                    task: `Im nächsten Schritt Ihrer Bestellung markieren Sie nun zusätzlich zur bestehenden Auswahl kaffee ODER mokka, was Sie mit der Eingabe <span class="searchPhrase">sahne</span> bekommen.`,
                    wrong: `Das war noch nicht ganz korrekt. Kleiner Tipp: Insgesamt bekommen Sie in diesem Schritt für die Eingabe von sahne 2 Spezialitäten von unserer Karte.`,
                    correct: `Richtig! Führen Sie nun die nächste Eingabe aus.`
                }, {
                    task: `Im nächsten Schritt Ihrer Bestellung markieren Sie nun zusätzlich zur bestehenden Auswahl, was Sie mit der Eingabe <span class="searchPhrase">obers</span> bekommen.`,
                    wrong: `Das war noch nicht ganz korrekt. Kleiner Tipp: Insgesamt bekommen Sie in diesem Schritt für die Eingabe von obers 2 Spezialitäten von unserer Karte.`,
                    correct: `Richtig! Sie haben nun alle Eingaben einzeln nacheinander ausgeführt. Es ist an der Zeit, diese nun zu koordinieren.`
                }
            ]
        },
        { //page15
            headline: `Phrasenbildung`,
            intro: `Die Phrasensuche kennen Sie aus dem Umgang mit Suchmaschinen: Wenn Sie eine bestimmte Wortfolge in Anführungszeichen setzen, bekommen Sie Treffer, in denen genau diese Wortfolge vorkommt. Wenn Sie die Anführungszeichen weglassen, bekommen Sie hingegen Treffer, in denen die Worte unabhängig von der Reihenfolge vorkommen.`,
            explanation: `Manche Ressourcen erlauben das Setzen eines Trunkierungszeichens (Wildcard-Operator, Joker, Platzhalter, s.o.) innerhalb der Phrasensuche. Es ersetzt dann nicht einen oder mehrere Buchstaben, sondern ein Wort. Es gibt auch gelegentlich Abstandsoperatoren, mit denen Sie den Abstand festlegen können, der maximal zwischen zwei Teilen einer Phrase liegen darf. Bitte lesen Sie die Hilfetexte der jeweiligen Ressource, um diese Suchformulierung zu erfahren.`,
            exampleHeadline: `Beispiele`,
            exampleExplanation: `Mit der Eingabe <span class="searchPhrase">"grundzüge der volkswirtschaftslehre"</span> im Feld <span class="fieldName">alle Wörter</span> erhalten Sie u.a.`,
            exampleResults: [
                `Mankiw: Grundzüge der Volkswirtschaftslehre`,
                `Wienert: Grundzüge der Volkswirtschaftslehre`,
                `Hermann: Arbeitsbuch Grundzüge der Volkswirtschaftslehre`
            ],
            examplePlusExplanation: `Mit der Eingabe <span class="searchPhrase">"gesellschaft * medien"</span> im Feld <span class="fieldName">Titel</span> erhalten Sie u.a.:`,
            examplePlusResults: [
                `Müller: Gesellschaft und Medien`,
                `Ziemann: Medien der Gesellschaft – Gesellschaft der Medien`,
                `Gottwald: Alte Gesellschaft – neue Medien`,
                `Langenbucher: Gesellschaft, elektronische Medien und Demokratie`,
                `<strong>Aber nicht:</strong> Kamps: Die offene Gesellschaft und ihre Medien, weil * nur ein Wort ersetzt.`
            ]
        },
        { //page16
            headline: `Schlagwort`,
            intro: [
                `Manche Ressourcen bieten eine Schlagwortsuche an, auf Englisch werden dafür die Benennungen "Descriptor", "Subject (Term)" und gelegentlich "Keyword" benutzt.`,
                `Gemeint ist damit, dass eine Indexiererin oder ein Indexierer den Inhalt eines Dokuments mit Schlagworten beschreibt, die unabhängig von der Terminologie des Dokuments sind. Die Schlagworte werden einer Wortliste mit kontrolliertem Vokabular (einem Thesaurus) entnommen und sind damit standardisiert. So wird in deutschsprachigen Schlagwortsystemen durchweg die Einzahl verwendet, in englischsprachigen überwiegend die Mehrzahl. Homonyme werden durch Zusätze eindeutig gemacht ("Krebs <Tier>", "Krebs <Erkrankung>") und Synonyme werden vermieden.`,
                `Die Suche mit Schlagworten führt zu besseren Ergebnissen, weil nach Inhalten gesucht wird und nicht nach Begriffen, die zufällig auch in dem Dokument vorkommen, aber wenig mit dem Inhalt des Dokuments zu tun haben.`,
                `Welches Schlagwort für welchen Zusammenhang benutzt wird, erfahren Sie beispielsweise, indem Sie mit Stichworten Zufallstreffer erzielen und die Schlagworte, die für diese Zufallstreffer vergeben wurden, notieren und mit ihnen eine neue Suche starten.`
            ],
            exampleHeadline: `Beispiel`,
            examples: [
                {
                    intro: `Mit der Eingabe <span class="searchPhrase">total quality management</span> im Feld <span class="fieldName">Alle Wörter</span> finden Sie u.a.`,
                    result: [
                        `Saint Clair: Total quality management in information services`
                    ],
                    outro: `In den Metadaten dieses Dokuments sehen Sie, dass für diese Quelle  u.a. das Schlagwort "Qualitätsmanagement" vergeben wurde.`
                },
                {
                    intro: `Mit der Eingabe <span class="searchPhrase">Qualitätsmanagement</span> im Feld <span class="fieldName">Schlagwörter</span> finden Sie auch`,
                    result: [
                        `Pfaff: ISO 9001:2008 : Basis für praxisgerechte Managementsysteme`,
                        `Osterhage: Abnahme komplexer Software-Systeme : das Praxishandbuch`,
                        `Feldmann: Montage in der Leistungselektronik für globale Märkte : Design, Konzepte, Strategien`
                    ]
                }
            ]
        },
        {//page17
            headline: `Übung`,
            wrong: `Das war noch nicht ganz korrekt. Kleiner Tipp: Sie erhalten 4 Spezialitäten von unserer Karte.`,
            explanation: `Sie wünschen Kaffee im Glas und bestellen mit der Eingabe <span class="searchPhrase">Kaffee UND Glas</span> im Feld <span class="fieldName">Schlagworte</span>.`
        },
        {//page18
            headline: `Klassifikation`,
            intro: [
                `Manche Ressourcen bieten die Suchmöglichkeit mit der Hilfe einer Klassifikation oder Systematik (classification, subject). Dafür ordnet eine Indexiererin oder ein Indexierer die Dokumente in Klassen an. Jedes Dokument in einer Klasse hat dabei mindestens ein inhaltliches Merkmal, das es mit allen Dokumenten der Klasse gemeinsam hat und das sich unterscheidet von den Merkmalen der Dokumente der anderen Klassen. Jede Klasse hat eine eigene Benennung, die mit einer Notation verschlüsselt wird.`,
                `Sie kennen Systematiken als Stammbaum in der Biologie und als Aufstellungssystematik in der Bibliothek. Wenn Sie ein Buch im Regal gefunden haben, das inhaltlich Ihren Vorstellungen entspricht, dann sehen Sie sich auch die Bücher links und rechts von dem gefundenen an, denn die behandeln wahrscheinlich das gleiche Thema.`,
                `In einer Bibliothek steht ein Buch immer nur an einer Stelle, auch wenn es inhaltlich an zwei Stellen stehen könnte. In virtuellen Systematiken kann ein Dokument auch mehreren Klassen zugeordnet werden. Sie suchen mit der Hilfe einer Klassifikation, ähnlich wie mit Schlagworten, nach Inhalten und nicht nach zufälligen Stichworten. Die klassifikatorische Suche wird zumeist als Unterstützung anderer Recherchen eingesetzt, beispielsweise zur Einschränkung einer großen Treffermenge auf einen fachlichen Zusammenhang.`
            ],
            exampleHeadline: `Beispiel`,
            examples: [
                {
                    intro: [`Mit der Eingabe <span class="searchPhrase">Qualitätsmanagement</span> im Feld <span class="fieldName">Alle Wörter</span> finden Sie u.a.`],
                    results: [`Qualitätsmanagement DIN EN ISO 9000 ff : Dokumentensammlung – mit der Signatur "Bwl 024 118"`]
                },
                {
                    intro: [
                        `Die Klasse mit der Notation Bwl 024 wurde Qualitätsmanagement benannt. In den Regalen mit der Bezeichnung Bwl 024 finden Sie also Bücher zum gleichen Thema und zwar nur die, die nicht ausgeliehen sind. Im Katalog können Sie zusätzlich feststellen, welche Bücher zum Thema derzeit ausgeliehen sind.`,
                        ` Mit der Eingabe Bwl 024* (Trunkierung) im Feld Signatur erhalten Sie alle Treffer, die der Klasse Qualitätsmanagement zugeordnet wurden, u.a.`
                    ],
                    results: [
                        `Suganthi: Total Quality Management`,
                        `European Foundation for Quality Management: Excellence einführen`,
                        `Loch: Industrial excellence : management quality in manufacturing`
                    ]
                }
            ],
        },
        {//page19
            headline: `Übung`,
            explanation: ` Markieren Sie nun für folgende Spezialität die richtige Klasse:`,
            tasks: [
                {
                    task: `<b>Türk Kahvesi</b> - <i>feinst gemahlener Kaffee, mit Zucker im Kupferkännchen aufgekocht</i>`,
                    wrong: `Das war noch nicht ganz korrekt. Kleiner Tipp: Die Spezialität ist genau einer richtigen Klasse zuzuordnen.`,
                    correct: `Richtig! Dann schauen wir mal, ob Sie auch die folgende Spezialität der richtigen Klasse zuordnen können.`
                },
                {
                    task: `<b>Wiener Eiskaffee</b> - <i>köstliches Vanilleeis, doppelter Mokka, Schlagobershaube, Kaffeebohne und Hohlhippe</i>`,
                    wrong: `Das war noch nicht ganz korrekt. Kleiner Tipp: Die Spezialität ist genau einer richtigen Klasse zuzuordnen.`,
                    correct: `Richtig! Dann schauen wir mal, ob Sie auch die folgende Spezialität der richtigen Klasse zuordnen können.`
                },
                {
                    task: `<b>Fiaker</b> - <i>Doppelmokka im Henkelglas mit einem Schuss Kirschwasser gespritzt, mit Schlagobershaube und Cocktailkirsche</i>`,
                    wrong: `Das war noch nicht ganz korrekt. Kleiner Tipp: Die Spezialität ist genau einer richtigen Klasse zuzuordnen.`
                }
            ]
        },
        {//page20
            headline: `Danke`,
            relax: `... für das Mitmachen. Hoffentlich war diese Übung nützlich für Sie.`,
            thanks: `Zur Entspannung der Magennerven`
        },
        {//page21
            headline: `Feedback`,
            intro: `Bitte markieren Sie mit einem Mausklick den Punkt, der ihrer Meinung entspricht.`,
            enjoyed: `Ich kann von dem Modul gebrauchen`,
            learned: `Ich habe Neues erfahren`,
            bad: `nichts`,
            good: `sehr viel`
        },
        {//page22
            headline: `Impressum`,
            email: `E-Mail`,
            projectTitle: `Projekt:`,
            authorTitle: `Autor:`,
            designTitle: `Design:`,
            productionTitle: `Produktion:`,
            iconsTitle: `Icons:`,
            iconsContent: `CC 3.0 BY <a href="http://www.flaticon.com/packs/material-design">Material UI by Google</a>`,
            origin: ` ursprünglich produziert im Rahmen des Projekts "Competence Cluster Medienkonzeption und netzgestütztes Lehren und Lernen CCM>L", finanziert durch Studiengebühren der Hochschule für Angewandte Wissenschaften Hamburg.`,
            license: {
                header: `Lizenzen`,
                contentTitle: `Inhalt:`,
                contentContent: `<a href="https://creativecommons.org/licenses/by-sa/4.0/">CC BY-SA 4.0</a><br/>`,
                codeTitle: `Code:`,
                codeContent: `<a href="https://opensource.org/licenses/MIT">MIT</a>`
            }
        }

    ],
    feedbackConfirmBox: {
        yes: `Bestätigen`,
        no: `Nein, doch nicht`,
        thanks: `Vielen Dank!`
    }
};


text:
@extends('layouts.masters')
@section('title', 'Sign up')
@section('content')

Sign up

        <form class="form" action="/auth/register" method="post">
            {!! csrf_field() !!}

                first name
                <input class="form-control" type="text" name="first_name" value="{{ old('first_name')  }}"/>

                Last name
                <input class="form-control" type="text" name="last_name" value="{{ old('last_name')  }}"/>

                Email
                <input class="form-control" type="text" name="email" value="{{ old('email')  }}"/>

                Password
                <input class="form-control" type="password" name="password"/>

                confirm passoword
                <input class="form-control" type="password" name="password_confirmation"/>

                <button class="btn btn-lg btn-success pull-right" type="submit">Register</button>

        </form>

@endsection


text:
import saopy.model

from saopy.model import sao___DiscreteCosineTransform as DiscreteCosineTransform
from saopy.model import sao___DiscreteFourierTransform as DiscreteFourierTransform
from saopy.model import sao___DiscreteWaveletTransform as DiscreteWaveletTransform
from saopy.model import sao___Mean as Mean
from saopy.model import sao___Median as Median
from saopy.model import sao___PiecewiseAggregateApproximation as PiecewiseAggregateApproximation
from saopy.model import sao___Point as Point
from saopy.model import sao___Segment as Segment
from saopy.model import sao___SensorSAX as SensorSAX
from saopy.model import sao___StreamAnalysis as StreamAnalysis
from saopy.model import sao___StreamData as StreamData
from saopy.model import sao___StreamEvent as StreamEvent
from saopy.model import sao___SymbolicAggregateApproximation as SymbolicAggregateApproximation


text:
<configuration name="acl.conf" description="Network Lists">
  <network-lists>
    <!--
	 These ACL's are automatically created on startup.

	 rfc1918.auto  - RFC1918 Space
	 nat.auto      - RFC1918 Excluding your local lan.
	 localnet.auto - ACL for your local lan.
	 loopback.auto - ACL for your local lan.
    -->

    <list name="lan" default="allow">
      <node type="deny" cidr="192.168.42.0/24"/>
      <node type="allow" cidr="192.168.42.42/32"/>
    </list>

    <!--
	This will traverse the directory adding all users
	with the cidr= tag to this ACL, when this ACL matches
	the users variables and params apply as if they
	digest authenticated.
    -->
    <list name="domains" default="deny">
      <!-- domain= is special it scans the domain from the directory to build the ACL -->
      <node type="allow" domain="$${domain}"/>
      <!-- use cidr= if you wish to allow ip ranges to this domains acl. -->
      <!-- <node type="allow" cidr="192.168.0.0/24"/> -->
    </list>

  </network-lists>
</configuration>


text:
package dockercredentials

import (
	"net/url"
	"reflect"
	"testing"

	"k8s.io/kubernetes/pkg/credentialprovider"
)

type mockKeyring struct {
	calls []string
}

func (k *mockKeyring) Lookup(image string) ([]credentialprovider.LazyAuthConfiguration, bool) {
	k.calls = append(k.calls, image)
	return nil, false
}

func TestHubFallback(t *testing.T) {
	k := &mockKeyring{}
	BasicFromKeyring(k, &url.URL{Host: "auth.docker.io", Path: "/token"})
	if !reflect.DeepEqual([]string{"auth.docker.io/token", "index.docker.io", "docker.io"}, k.calls) {
		t.Errorf("unexpected calls: %v", k.calls)
	}
}

func Test_BasicFromKeyring(t *testing.T) {
	fn := func(host string, entry credentialprovider.DockerConfigEntry) credentialprovider.DockerKeyring {
		k := &credentialprovider.BasicDockerKeyring{}
		k.Add(map[string]credentialprovider.DockerConfigEntry{host: entry})
		return k
	}
	def := credentialprovider.DockerConfigEntry{
		Username: "local_user",
		Password: "local_pass",
	}
	type args struct {
		keyring credentialprovider.DockerKeyring
		target  *url.URL
	}
	tests := []struct {
		name     string
		args     args
		user     string
		password string
	}{
		{name: "exact", args: args{keyring: fn("localhost", def), target: &url.URL{Host: "localhost"}}, user: def.Username, password: def.Password},
		{name: "https scheme", args: args{keyring: fn("localhost", def), target: &url.URL{Scheme: "https", Host: "localhost"}}, user: def.Username, password: def.Password},
		{name: "canonical https", args: args{keyring: fn("localhost", def), target: &url.URL{Scheme: "https", Host: "localhost:443"}}, user: def.Username, password: def.Password},
		{name: "only https", args: args{keyring: fn("https://localhost", def), target: &url.URL{Host: "localhost"}}, user: def.Username, password: def.Password},
		{name: "only https scheme", args: args{keyring: fn("https://localhost", def), target: &url.URL{Scheme: "https", Host: "localhost"}}, user: def.Username, password: def.Password},

		{name: "mismatched scheme - http", args: args{keyring: fn("http://localhost", def), target: &url.URL{Scheme: "https", Host: "localhost"}}, user: def.Username, password: def.Password},
		{name: "don't assume port 80 in keyring is https", args: args{keyring: fn("localhost:80", def), target: &url.URL{Scheme: "http", Host: "localhost"}}, user: def.Username, password: def.Password},
		{name: "exact http", args: args{keyring: fn("localhost:80", def), target: &url.URL{Scheme: "http", Host: "localhost:80"}}, user: def.Username, password: def.Password},

		// this is not allowed by the credential keyring, but should be
		{name: "exact http", args: args{keyring: fn("http://localhost", def), target: &url.URL{Scheme: "http", Host: "localhost:80"}}, user: "", password: ""},
		{name: "keyring canonical https", args: args{keyring: fn("localhost:443", def), target: &url.URL{Scheme: "https", Host: "localhost"}}, user: "", password: ""},

		// these should not be allowed
		{name: "host is for port 80 only", args: args{keyring: fn("localhost:80", def), target: &url.URL{Host: "localhost"}}, user: "", password: ""},
		{name: "host is for port 443 only", args: args{keyring: fn("localhost:443", def), target: &url.URL{Host: "localhost"}}, user: "", password: ""},
		{name: "canonical http", args: args{keyring: fn("localhost", def), target: &url.URL{Scheme: "http", Host: "localhost:80"}}, user: "", password: ""},
		{name: "http scheme", args: args{keyring: fn("localhost", def), target: &url.URL{Scheme: "http", Host: "localhost"}}, user: "", password: ""},
		{name: "https not canonical", args: args{keyring: fn("localhost", def), target: &url.URL{Scheme: "https", Host: "localhost:80"}}, user: "", password: ""},
		{name: "http not canonical", args: args{keyring: fn("localhost", def), target: &url.URL{Scheme: "http", Host: "localhost:443"}}, user: "", password: ""},
		{name: "mismatched scheme", args: args{keyring: fn("https://localhost", def), target: &url.URL{Scheme: "http", Host: "localhost"}}, user: "", password: ""},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			user, password := BasicFromKeyring(tt.args.keyring, tt.args.target)
			if user != tt.user {
				t.Errorf("BasicFromKeyring() user = %v, actual = %v", user, tt.user)
			}
			if password != tt.password {
				t.Errorf("BasicFromKeyring() password = %v, actual = %v", password, tt.password)
			}
		})
	}
}


text:
					 <#LANG_DEVICE#>
					 <#LANG_SCRIPT#>
					 <#LANG_OBJECT#>
					 <#LANG_NEWDASH_CLASS#>

<#LANG_NEWDASH_DONTSHOW_THIS_BLOCK#>

<#LANG_NEWDASH_DMB_TITLE#>

						<button type="button" class="close" data-dismiss="modal" aria-hidden="true">×</button>

<#LANG_NEWDASH_DMB_TITLE_MODAL#>

							<#LANG_NEWDASH_DMB_TITLE_MODAL_HINT#> <#LANG_NEWDASH_DMB_TITLE_MODAL_HINT_FORUM#>

<#LANG_NEWDASH_DMB_TITLE_MODAL_STEP1#> dash_my_block

								<#LANG_NEWDASH_DMB_TITLE_MODAL_STEP2#>

$array = array(

	'status' => 1,

	'name' => 'Супер блок',

	'reload' => true,

	'reload_time' => 5,

	'data' => array(

		'data' => 'Привет! Тут любой html!'

	),

);

echo json_encode($array);

<#LANG_NEWDASH_DMB_TITLE_MODAL_STEP3#>

						<button type="button" class="btn btn-default" data-dismiss="modal"><#LANG_CLOSE#></button>

<#LANG_NEWDASH_SYSTEM_INFO#>

							<#LANG_NEWDASH_SYSTEM_INFO_DB_STATUS#>
							<img src="<#ROOTHTML#>img/ajax-loader.gif"/>

							<#LANG_DEVICES_STATUS#> WebSocket
							<img src="<#ROOTHTML#>img/ajax-loader.gif"/>

							<#LANG_NEWDASH_DB_REQ_SEC#>
							<img src="<#ROOTHTML#>img/ajax-loader.gif"/>

							<#LANG_NEWDASH_DB_REQ_MIN#>
							<img src="<#ROOTHTML#>img/ajax-loader.gif"/>

							<#LANG_NEWDASH_DB_REQ_HOUR#>
							<img src="<#ROOTHTML#>img/ajax-loader.gif"/>

							Обсуждение на форуме

								<img src="<#ROOTHTML#>img/ajax-loader.gif"/>

							Текущая версия MJDM:

								<img src="<#ROOTHTML#>img/ajax-loader.gif"/>

							<#LANG_NEWDASH_SYSTEM_INFO_LAST_UPDATE#>

<img src="<#ROOTHTML#>img/ajax-loader.gif"/> <#LANG_NEWDASH_LOADING#>

<#LANG_NEWDASH_CYCLE_CONTROL#>  X-Ray

<img src="<#ROOTHTML#>img/ajax-loader.gif"/> <#LANG_NEWDASH_LOADING#>

<#LANG_NEWDASH_LAST_SCRIPTS#>  <#LANG_NEWDASH_LAST_SCRIPTS_GO#>

<#LANG_NEWDASH_SHOW_LAST_SCRIPTS#>

						<img src="<#ROOTHTML#>img/ajax-loader.gif"/> <#LANG_NEWDASH_LOADING#>

<#LANG_NEWDASH_HINT_BIG_DATA_DB#>  X-Ray

<#LANG_NEWDASH_DONTSHOW_THIS_BLOCK#>

<img src="<#ROOTHTML#>img/ajax-loader.gif"/> <#LANG_NEWDASH_LOADING#>

Новые сценарии!

				Обновили модуль сценарии! Зацените как удобно стало. Анимации, мобильный вид - все в лучших традициях =)

<#LANG_NEWDASH_HELLO_NEW_BTN#>

<#LANG_NEWDASH_CONNECT_ADS#>

<#LANG_NEWDASH_CONNECT_ADS_TEXT#>

				<a style="border-color: #ffffff;" onclick="$('#btnConnect').hide();$('#titleConnect').text('<#LANG_NEWDASH_CONNECT_ADS_DONATE#>');$('#textConnect').html('<#LANG_NEWDASH_CONNECT_ADS_DONATE_TEXT#>');" class="btn btn-default btn-md" role="button"><#LANG_NEWDASH_CONNECT_ADS_DONATE_BTN#>
				<#LANG_NEWDASH_CONNECT_ADS_BTN#>

				<button type="button" class="close" data-dismiss="alert" aria-hidden="true">×</button>

					<img src="<#ROOTHTML#>img/ajax-loader.gif"/> <#LANG_NEWDASH_LOADING#>

<#LANG_NEWDASH_DONTSHOW_THIS_BLOCK#>

<#LANG_NEWDASH_NEWS#>  <#LANG_NEWDASH_NEWS_MORE#>

<img src="<#ROOTHTML#>img/ajax-loader.gif"/> <#LANG_NEWDASH_LOADING#>

[#endif#]


text:
package main

import (
	"./embedded"
	"fmt"
)

func user_init() {

	//play with the SD card a bit
	good, root := embedded.Fat32_som_start(embedded.Init_som_sdcard, embedded.Read_som_sdcard)
	if !good {
		fmt.Println("fat32 init failure")
	}
	fmt.Println(root.Getfilenames())
	fmt.Println(root.Getsubdirnames())
	good, bootdir := root.Direnter("BOOT")
	if !good {
		panic("dir entry failed")
	} else {
		fmt.Println(bootdir.Getfilenames())
		good, contents := bootdir.Fileread("UENV.TXT")
		if !good {
			panic("file read failure")
		}
		fmt.Println(string(contents))
	}
	//embedded.WB_JP4_4.SetOutput()
	//embedded.WB_JP4_6.SetOutput()
	count = 0
	//	ping = false
	embedded.WB_JP4_6.SetInput()
	embedded.WB_JP4_6.EnableIntr(embedded.INTR_RISING, inc)
	embedded.Enable_interrupt(103, 0) //send GPIO3 interrupt to CPU0

	//send the GPT interrupt to CPU1
	embedded.Enable_interrupt(87, 1)

	//start the GPT
	embedded.StartGPT()

	//start a little watch
	go embedded.Gopherwatch()
}

func user_loop() {
	//	embedded.WB_JP4_6.SetLO()
	//	embedded.WB_JP4_6.SetHI()
	//	if ping {
	//		fmt.Printf("count is %d\n", count)
	//		ping = false
	//	}
	embedded.Sleep(2)
	fmt.Printf("count is %d\n", count)
}

//var ping bool
var count uint32

//go:nosplit
func inc() {
	count += 1
	//	if count%5 == 0 {
	//		ping = true
	//	}
}


text:
package org.assertj.core.error;

import static junit.framework.Assert.assertEquals;

import static org.assertj.core.error.ShouldNotBeEqual.shouldNotBeEqual;

import org.assertj.core.internal.*;
import org.assertj.core.presentation.StandardRepresentation;
import org.assertj.core.util.CaseInsensitiveStringComparator;
import org.junit.Before;
import org.junit.Test;

/**
 * Tests for <code>{@link ShouldNotBeEqual#create(org.assertj.core.description.Description, org.assertj.core.presentation.Representation)}</code>.
 *
 * @author Alex Ruiz
 * @author Joel Costigliola
 */
public class ShouldNotBeEqual_create_Test {

  private ErrorMessageFactory factory;

  @Before
  public void setUp() {
    factory = shouldNotBeEqual("Yoda", "Luke");
  }

  @Test
  public void should_create_error_message() {
    String message = factory.create(new TestDescription("Jedi"), new StandardRepresentation());
    assertEquals("[Jedi] \nExpecting:\n <\"Yoda\">\nnot to be equal to:\n <\"Luke\">\n", message);
  }

  @Test
  public void should_create_error_message_with_custom_comparison_strategy() {
    factory = shouldNotBeEqual("Yoda", "Luke", new ComparatorBasedComparisonStrategy(CaseInsensitiveStringComparator.instance));
    String message = factory.create(new TestDescription("Jedi"), new StandardRepresentation());
    assertEquals(
        "[Jedi] \nExpecting:\n <\"Yoda\">\nnot to be equal to:\n <\"Luke\">\nwhen comparing values using 'CaseInsensitiveStringComparator'", message);
  }
}


text:
using namespace hypha::settings;

ConfigGenerator::ConfigGenerator() {}

void ConfigGenerator::generateConfigFile(std::string filename) {
  Poco::AutoPtr<Poco::Util::XMLConfiguration> settings =
      new Poco::Util::XMLConfiguration();
  settings->loadEmpty("hypha");
  settings->save(filename);
  settings->createView("database");
  settings->setString("database.database", dbDatabase);
  settings->setString("database.driver", dbDriver);
  settings->setString("database.host", dbHost);
  settings->setInt("database.port", dbPort);
  settings->setString("database.username", dbUsername);
  settings->setString("database.password", dbPassword);

  settings->createView("userdatabase");
  settings->setString("userdatabase.database", udbDatabase);
  settings->setString("userdatabase.driver", udbDriver);
  settings->setString("userdatabase.host", udbHost);
  settings->setInt("userdatabase.port", udbPort);
  settings->setString("userdatabase.username", udbUsername);
  settings->setString("userdatabase.password", udbPassword);
  settings->setString("userdatabase.table", udbTable);

  settings->setString("userdatabase.attrDevices", udbAttributeDevices);
  settings->setString("userdatabase.attrFirstname", udbAttributeFirstname);
  settings->setString("userdatabase.attrLastname", udbAttributeLastname);
  settings->setString("userdatabase.attrMail", udbAttributeMail);
  settings->setString("userdatabase.attrUsername", udbAttributeUsername);

  settings->save(filename);
}


text:
**NOTE**: we are no longer manually syncing buckets, however this may be a useful
fallback reference.  Syncs are now done by the [gcs-to-s3-sync](https://testgrid.k8s.io/sig-k8s-infra-k8sio#gcs-to-s3-sync) prow job.

## Background

In the CNCF AWS accounts, there are two accounts of concern:

- _cncf/kubernetes/k8s-infra-accounts_
- _cncf/kubernetes/registry.k8s.io/registry.k8s.io_admin_

Using an IAM user inside of the k8s-infra-accounts account, it is possible to write to the registry.k8s.io mirror buckets.

## Logging in

Log in as an IAM user, which has the ability to assume the _registry.k8s.io_s3writer_ role:

```bash
aws configure
```

## Assuming roles

In order to gain permissions to write to the buckets, it is required to call STS to assume the _registry.k8s.io_s3writer_ role:

```bash
unset AWS_ACCESS_KEY_ID AWS_SECRET_ACCESS_KEY AWS_SESSION_TOKEN
JSON=$(aws sts assume-role \
  --role-arn "arn:aws:iam::513428760722:role/registry.k8s.io_s3writer"  \
  --role-session-name registry.k8s.io_s3writer \
  --duration-seconds 3600 \
  --output json || exit 1)

export \
  AWS_ACCESS_KEY_ID=$(echo "${JSON}" | jq --raw-output ".Credentials[\"AccessKeyId\"]") \
  AWS_SECRET_ACCESS_KEY=$(echo "${JSON}" | jq --raw-output ".Credentials[\"SecretAccessKey\"]") \
  AWS_SESSION_TOKEN=$(echo "${JSON}" | jq --raw-output ".Credentials[\"SessionToken\"]")
```

## Set up rclone

Configure rclone to auth both with GCS and S3

```bash
cat << EOF > ~/.rclone.conf
[gcs]
type = google cloud storage
bucket_acl = private

[s3]
type = s3
provider = AWS
access_key_id = $AWS_ACCESS_KEY_ID
secret_access_key = $AWS_SECRET_ACCESS_KEY
session_token = $AWS_SESSION_TOKEN
region = us-east-2
EOF
```

## Performing the sync

The following set of commands will perform a sync, first between GCS US region and S3 us-east-2, then between S3 us-east-2 and the remaining regions

```bash
REGIONS=(
    prod-registry-k8s-io-ap-southeast-1
    prod-registry-k8s-io-ap-southeast-2
    prod-registry-k8s-io-ap-south-1

    prod-registry-k8s-io-us-west-1
    prod-registry-k8s-io-us-west-2
    prod-registry-k8s-io-us-east-1

    prod-registry-k8s-io-eu-central-1
    prod-registry-k8s-io-eu-west-1
)

# initial sync (gcs us -> s3 us)
rclone sync -P gcs:us.artifacts.k8s-artifacts-prod.appspot.com s3:prod-registry-k8s-io-us-east-2

for REGION in "${REGIONS[@]}"; do
  rclone config update s3 region "${REGION}"
  rclone sync -P s3:prod-registry-k8s-io-us-east-2 "s3:${REGION}"
done
```


text:
<?xml version="1.0" encoding="UTF-8"?>
<jboss-web>
	<listener>
		<class-name>org.apache.catalina.core.JreMemoryLeakPreventionListener</class-name>
		<listener-type>LIFECYCLE</listener-type>
	</listener>

	<listener>
		<class-name>com.a9ski.catalina.MemoryLeakPreventionListener</class-name>
		<listener-type>LIFECYCLE</listener-type>
		<param>
			<param-name>keepAlivePreventionDisabled</param-name>
			<param-value>false</param-value>
		</param>
		<param>
			<param-name>cleanThreadLocalsDisabled</param-name>
			<param-value>false</param-value>
		</param>
		<param>
			<param-name>cleanThreadLocalsInNewThread</param-name>
			<param-value>false</param-value>
		</param>
		<param>
			<param-name>cleanThreadLocalsWaitTime</param-name>
			<param-value>0</param-value>
		</param>
		<param>
			<param-name>lifecycleEventType</param-name>
			<param-value>destroy</param-value>
		</param>

	</listener>
</jboss-web>


text:
Addresstypes

				Posted on

				by

    	No Addresstypes yet, why don't you create one?


text:
<?php

namespace Gitlab\Test\Entity;

use Gitlab\Entity\User;
use PHPUnit_Framework_TestCase;

class UserTest extends PHPUnit_Framework_TestCase
{
    public function testFromArray()
    {
        $actual = User::fromArray([
            'id' => 1,
            'username' => 'john_smith',
            'name' => 'John Smith',
            'state' => 'active',
            'avatar_url' => 'http=>//localhost=>3000/uploads/user/avatar/1/cd8.jpeg',
        ]);

        $this->assertEquals(1, $actual->id);
        $this->assertEquals('john_smith', $actual->username);
        $this->assertEquals('John Smith', $actual->name);
        $this->assertEquals('active', $actual->state);
        $this->assertEquals('http=>//localhost=>3000/uploads/user/avatar/1/cd8.jpeg', $actual->avatarUrl);
    }
}


text:
<!DOCTYPE html>
<html>
<head>
	<meta charset="utf-8">
	<meta http-equiv="X-UA-Compatible" content="IE=edge">
	<title><?php readfile("../" . $config['sources_path'] . "website_title.html") ?></title>
	<meta name="robots" content="all" />
	<meta name="description" content="<?php readfile("../" . $config['sources_path'] . "description.html") ?>" />
	<meta name="keywords" content="<?php readfile("../" . $config['sources_path'] . "keywords.html") ?>" />

	<meta name="HandheldFriendly" content="True">
    <meta name="MobileOptimized" content="320">
    <meta name="viewport" content="width=device-width, initial-scale=1, minimal-ui">
    <meta http-equiv="cleartype" content="on">

	<?php include('./layout/assets.php'); ?>

</head>

<body>


text:
module Spree
  module Admin
    class StockLocationsController < ResourceController

      before_filter :set_country, :only => :new

      private

      def set_country
        begin
          if Spree::Config[:default_country_id].present?
            @stock_location.country = Spree::Country.find(Spree::Config[:default_country_id])
          else
            @stock_location.country = Spree::Country.find_by!(iso: 'US')
          end

        rescue ActiveRecord::RecordNotFound
          flash[:error] = Spree.t(:stock_locations_need_a_default_country)
          redirect_to admin_stock_locations_path and return
        end
      end

    end
  end
end


text:
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <parent>
        <artifactId>backend</artifactId>
        <groupId>at.fhj.swd14.pse</groupId>
        <version>1.2-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>backend-impl</artifactId>
    <packaging>ejb</packaging>

    <dependencies>
        <dependency>
            <groupId>at.fhj.swd14.pse</groupId>
            <artifactId>backend-interface</artifactId>
            <scope>provided</scope>
        </dependency>
        <dependency>
            <groupId>javax</groupId>
            <artifactId>javaee-api</artifactId>
        </dependency>
        <dependency>
            <groupId>org.apache.logging.log4j</groupId>
            <artifactId>log4j-core</artifactId>
        </dependency>

        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
        </dependency>
        <dependency>
            <groupId>org.mockito</groupId>
            <artifactId>mockito-all</artifactId>
        </dependency>
        <dependency>
            <groupId>at.fhj.swd14.pse</groupId>
            <artifactId>backend-testing-commons</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-java8</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-ejb-plugin</artifactId>
                <configuration>
                    <ejbVersion>${ejb.version}</ejbVersion>
                </configuration>
            </plugin>
        </plugins>
    </build>

</project>


text:
using System;
using System.Collections.Concurrent;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Foundatio.Logging;
using Foundatio.Logging.Xunit;
using Foundatio.Storage;
using Foundatio.Tests.Utility;
using Xunit;
using Foundatio.Utility;
using Xunit.Abstractions;

namespace Foundatio.Tests.Storage {
    public abstract class FileStorageTestsBase : TestWithLoggingBase {
        protected FileStorageTestsBase(ITestOutputHelper output) : base(output) {}

        protected virtual IFileStorage GetStorage() {
            return null;
        }

        public virtual async Task CanGetEmptyFileListOnMissingDirectory() {
            await ResetAsync();

            IFileStorage storage = GetStorage();
            if (storage == null)
                return;

            using (storage) {
                Assert.Equal(0, (await storage.GetFileListAsync(Guid.NewGuid() + "\\*")).Count());
            }
        }

        public virtual async Task CanGetFileListForSingleFolder() {
            await ResetAsync();

            IFileStorage storage = GetStorage();
            if (storage == null)
                return;

            using (storage) {
                await storage.SaveFileAsync(@"archived\archived.txt", "archived");
                await storage.SaveFileAsync(@"q\new.txt", "new");
                Assert.Equal(2, (await storage.GetFileListAsync()).Count());
                Assert.Equal(1, (await storage.GetFileListAsync(limit: 1)).Count());
                Assert.Equal(1, (await storage.GetFileListAsync(@"archived\*")).Count());
                Assert.Equal(1, (await storage.GetFileListAsync(@"q\*")).Count());

                var file = (await storage.GetFileListAsync(@"archived\*")).FirstOrDefault();
                Assert.NotNull(file);
                Assert.Equal("archived", await storage.GetFileContentsAsync(@"archived\archived.txt"));

                file = (await storage.GetFileListAsync(@"q\*")).FirstOrDefault();
                Assert.NotNull(file);
                Assert.Equal("new", await storage.GetFileContentsAsync(@"q\new.txt"));
            }
        }

        public virtual async Task CanManageFiles() {
            await ResetAsync();

            IFileStorage storage = GetStorage();
            if (storage == null)
                return;

            using (storage) {
                await storage.SaveFileAsync("test.txt", "test");
                Assert.Equal(1, (await storage.GetFileListAsync()).Count());
                var file = (await storage.GetFileListAsync()).FirstOrDefault();
                Assert.NotNull(file);
                Assert.Equal("test.txt", file.Path);
                string content = await storage.GetFileContentsAsync("test.txt");
                Assert.Equal("test", content);
                await storage.RenameFileAsync("test.txt", "new.txt");
                Assert.True((await storage.GetFileListAsync()).Any(f => f.Path == "new.txt"));
                await storage.DeleteFileAsync("new.txt");
                Assert.Equal(0, (await storage.GetFileListAsync()).Count());
            }
        }

        public virtual async Task CanSaveFilesAsync() {
            await ResetAsync();

            IFileStorage storage = GetStorage();
            if (storage == null)
                return;

            string readmeFile = Path.GetFullPath(@"..\..\..\..\..\README.md");

            using (storage) {
                Assert.False(await storage.ExistsAsync("README.md"));

                using (var stream = new NonSeekableStream(File.Open(readmeFile, FileMode.Open, FileAccess.Read))) {
                    bool result = await storage.SaveFileAsync("README.md", stream);
                    Assert.True(result);
                }

                Assert.Equal(1, (await storage.GetFileListAsync()).Count());
                Assert.True(await storage.ExistsAsync("README.md"));

                using (var stream = await storage.GetFileStreamAsync("README.md")) {
                    string result = await new StreamReader(stream).ReadToEndAsync();
                    Assert.Equal(File.ReadAllText(readmeFile), result);
                }
            }
        }

        protected async Task ResetAsync() {
            var storage = GetStorage();
            if (storage == null)
                return;

            using (storage) {
                var files = (await storage.GetFileListAsync()).ToList();
                if (files.Any())
                    Debug.WriteLine("Got files");
                else
                    Debug.WriteLine("No files");
                await storage.DeleteFilesAsync(files);
                Assert.Equal(0, (await storage.GetFileListAsync()).Count());
            }
        }

        public virtual async Task CanConcurrentlyManageFiles() {
            await ResetAsync();

            IFileStorage storage = GetStorage();
            if (storage == null)
                return;

            using (storage) {
                const string queueFolder = "q";
                var queueItems = new BlockingCollection<int>();

                var info = await storage.GetFileInfoAsync("nope");
                Assert.Null(info);

                await Run.InParallel(10, async i => {
                    var ev = new PostInfo {
                        ApiVersion = 2,
                        CharSet = "utf8",
                        ContentEncoding = "application/json",
                        Data = Encoding.UTF8.GetBytes("{}"),
                        IpAddress = "127.0.0.1",
                        MediaType = "gzip",
                        ProjectId = i.ToString(),
                        UserAgent = "test"
                    };

                    await storage.SaveObjectAsync(Path.Combine(queueFolder, i + ".json"), ev);
                    queueItems.Add(i);
                });

                Assert.Equal(10, (await storage.GetFileListAsync()).Count());

                await Run.InParallel(10, async i => {
                    string path = Path.Combine(queueFolder, queueItems.Random() + ".json");
                    var eventPost = await storage.GetEventPostAndSetActiveAsync(Path.Combine(queueFolder, RandomData.GetInt(0, 25) + ".json"), _logger);
                    if (eventPost == null)
                        return;

                    if (RandomData.GetBool()) {
                        await storage.CompleteEventPost(path, eventPost.ProjectId, DateTime.UtcNow, true, _logger);
                    } else
                        await storage.SetNotActiveAsync(path, _logger);
                });
            }
        }
    }

    public class PostInfo {
        public int ApiVersion { get; set; }
        public string CharSet { get; set; }
        public string ContentEncoding { get; set; }
        public byte[] Data { get; set; }
        public string IpAddress { get; set; }
        public string MediaType { get; set; }
        public string ProjectId { get; set; }
        public string UserAgent { get; set; }
    }

    public static class StorageExtensions {
        public static async Task<PostInfo> GetEventPostAndSetActiveAsync(this IFileStorage storage, string path, ILogger logger = null) {
            PostInfo eventPostInfo = null;
            try {
                eventPostInfo = await storage.GetObjectAsync<PostInfo>(path);
                if (eventPostInfo == null)
                    return null;

                if (!await storage.ExistsAsync(path + ".x") && !await storage.SaveFileAsync(path + ".x", String.Empty))
                    return null;
            } catch (Exception ex) {
                logger?.Error(ex, () => $"Error retrieving event post data \"{path}\": {ex.Message}");
                return null;
            }

            return eventPostInfo;
        }

        public static async Task<bool> SetNotActiveAsync(this IFileStorage storage, string path, ILogger logger = null) {
            try {
                return await storage.DeleteFileAsync(path + ".x");
            } catch (Exception ex) {
                logger?.Error(ex, () => $"Error deleting work marker \"{path}.x\": {ex.Message}");
            }

            return false;
        }

        public static async Task<bool> CompleteEventPost(this IFileStorage storage, string path, string projectId, DateTime created, bool shouldArchive = true, ILogger logger = null) {
            // don't move files that are already in the archive
            if (path.StartsWith("archive"))
                return true;

            string archivePath = $"archive\\{projectId}\\{created.ToString("yy\\\\MM\\\\dd")}\\{Path.GetFileName(path)}";

            try {
                if (shouldArchive) {
                    if (!await storage.RenameFileAsync(path, archivePath))
                        return false;
                } else {
                    if (!await storage.DeleteFileAsync(path))
                        return false;
                }
            } catch (Exception ex) {
                logger?.Error(ex, () => $"Error archiving event post data \"{path}\": {ex.Message}");
                return false;
            }

            await storage.SetNotActiveAsync(path);

            return true;
        }
    }
}


text:
Sequel.migration do
  # Updates the database with the changes specified in the block.
  up do
    drop_column(:comments, :defensio_signature)
  end

  # Reverts the changes made in the up() block.
  down do
    add_column(:comments, :defensio_signature, String)
  end
end


text:
namespace syncer {

class CancelationSignal;
class CommitProcessor;
class GetUpdatesProcessor;

// A Syncer provides a control interface for driving the sync cycle.  These
// cycles consist of downloading updates, parsing the response (aka. process
// updates), applying updates while resolving conflicts, and committing local
// changes.  Some of these steps may be skipped if they're deemed to be
// unnecessary.
//
// A Syncer instance expects to run on a dedicated thread.  Calls to SyncShare()
// may take an unbounded amount of time because it may block on network I/O, on
// lock contention, or on tasks posted to other threads.
class SYNC_EXPORT_PRIVATE Syncer {
 public:
  typedef std::vector<int64> UnsyncedMetaHandles;

  Syncer(CancelationSignal* cancelation_signal);
  virtual ~Syncer();

  bool ExitRequested();

  // Fetches and applies updates, resolves conflicts and commits local changes
  // for |request_types| as necessary until client and server states are in
  // sync.  The |nudge_tracker| contains state that describes why the client is
  // out of sync and what must be done to bring it back into sync.
  virtual bool NormalSyncShare(ModelTypeSet request_types,
                               const sessions::NudgeTracker& nudge_tracker,
                               sessions::SyncSession* session);

  // Performs an initial download for the |request_types|.  It is assumed that
  // the specified types have no local state, and that their associated change
  // processors are in "passive" mode, so none of the downloaded updates will be
  // applied to the model.  The |source| is sent up to the server for debug
  // purposes.  It describes the reson for performing this initial download.
  virtual bool ConfigureSyncShare(
      ModelTypeSet request_types,
      sync_pb::GetUpdatesCallerInfo::GetUpdatesSource source,
      sessions::SyncSession* session);

  // Requests to download updates for the |request_types|.  For a well-behaved
  // client with a working connection to the invalidations server, this should
  // be unnecessary.  It may be invoked periodically to try to keep the client
  // in sync despite bugs or transient failures.
  virtual bool PollSyncShare(ModelTypeSet request_types,
                             sessions::SyncSession* session);

 private:
  bool DownloadAndApplyUpdates(
      ModelTypeSet request_types,
      sessions::SyncSession* session,
      GetUpdatesProcessor* get_updates_processor,
      bool create_mobile_bookmarks_folder);

  // This function will commit batches of unsynced items to the server until the
  // number of unsynced and ready to commit items reaches zero or an error is
  // encountered.  A request to exit early will be treated as an error and will
  // abort any blocking operations.
  SyncerError BuildAndPostCommits(
      ModelTypeSet request_types,
      sessions::SyncSession* session,
      CommitProcessor* commit_processor);

  void HandleCycleBegin(sessions::SyncSession* session);
  bool HandleCycleEnd(
      sessions::SyncSession* session,
      sync_pb::GetUpdatesCallerInfo::GetUpdatesSource source);

  syncer::CancelationSignal* const cancelation_signal_;

  friend class SyncerTest;
  FRIEND_TEST_ALL_PREFIXES(SyncerTest, NameClashWithResolver);
  FRIEND_TEST_ALL_PREFIXES(SyncerTest, IllegalAndLegalUpdates);
  FRIEND_TEST_ALL_PREFIXES(SyncerTest, TestCommitListOrderingAndNewParent);
  FRIEND_TEST_ALL_PREFIXES(SyncerTest,
                           TestCommitListOrderingAndNewParentAndChild);
  FRIEND_TEST_ALL_PREFIXES(SyncerTest, TestCommitListOrderingCounterexample);
  FRIEND_TEST_ALL_PREFIXES(SyncerTest, TestCommitListOrderingWithNesting);
  FRIEND_TEST_ALL_PREFIXES(SyncerTest, TestCommitListOrderingWithNewItems);
  FRIEND_TEST_ALL_PREFIXES(SyncerTest, TestGetUnsyncedAndSimpleCommit);
  FRIEND_TEST_ALL_PREFIXES(SyncerTest, TestPurgeWhileUnsynced);
  FRIEND_TEST_ALL_PREFIXES(SyncerTest, TestPurgeWhileUnapplied);
  FRIEND_TEST_ALL_PREFIXES(SyncerTest, UnappliedUpdateDuringCommit);
  FRIEND_TEST_ALL_PREFIXES(SyncerTest, DeletingEntryInFolder);
  FRIEND_TEST_ALL_PREFIXES(SyncerTest,
                           LongChangelistCreatesFakeOrphanedEntries);
  FRIEND_TEST_ALL_PREFIXES(SyncerTest, QuicklyMergeDualCreatedHierarchy);
  FRIEND_TEST_ALL_PREFIXES(SyncerTest, LongChangelistWithApplicationConflict);
  FRIEND_TEST_ALL_PREFIXES(SyncerTest, DeletingEntryWithLocalEdits);
  FRIEND_TEST_ALL_PREFIXES(EntryCreatedInNewFolderTest,
                           EntryCreatedInNewFolderMidSync);

  DISALLOW_COPY_AND_ASSIGN(Syncer);
};

}  // namespace syncer

#endif  // SYNC_ENGINE_SYNCER_H_