grosser

#!/bin/bash -e

# Kubernetes api server is supposed to run compaction on etcd
# when that does not happen we need to do an emergency compaction to make etcd not lock up
# this should only be done once, so we pick the leader to do it, which we assume is healthy
# (compacting manually outside of api server can lead to watches failing / requests for specific revisions failing etc)
#
# After compacting the keyspace, the backend database may exhibit internal fragmentation.
# Any internal fragmentation is space that is free to use by the backend but still consumes storage space.
# The process of defragmentation releases this storage space back to the file system.

nbibler

<MyVideo @video={{someVideoModelInstance}}/>

tgroshon

OOP Code smells

Things that might indicate a problem. RailsConf talk "Get a Whiff of This" by Sandi Metz

• Couplers: binds objects together
  • feature envy (send more messages to object than to self)
  • inappropriate intimacy (access private methods/data)
  • message chains (law of demeter; too many dots)
  • middle man (sole purpose to forward on calls)

vlasikhin

# сохраняем файл в корень проекта
# добавляем ссылку в гит:
# ln -s ../../rubocop_pre_commit_hook.rb .git/hooks/pre-commit
# проверяем добавился ли файл:
# ls -al .git/hooks/pre-commit
# должно быть что то типа: 
# Aug 11 13:17 .git/hooks/pre-commit -> ../../rubocop_pre_commit_hook.rb
# даем права:
# chmod +x .git/hooks/pre-commit
# проверяем:

samselikoff

// tests/helpers/push-mirage-db-into-store.js
import { registerAsyncHelper } from '@ember/test';
import { run } from '@ember/runloop';

let pushMirageDbIntoStore = function(server, store) {
  let tables = Object.keys(server.schema);

  tables.forEach(table => {
    if (server.schema[table].all) {
      let all = server.schema[table].all();

ccyrille

class User < ActiveRecord::Base
...
  # << REMOVE ON NEXT RELASE  
  def self.columns
    super.reject { |c| c.name == "removed_column" }
  end
  # >> REMOVE ON NEXT RELEASE
...
end

samselikoff

This assert.asyncThrows custom assertion allows us to write tests against failing async code, usually as a result of a server error (4xx/5xx response).

test('If the index route errors, I see a message', async function(assert) {
  server.create('post');
  server.get('/posts/:id', { errors: ['The site is down'] }, 500); // force Mirage to error

  await assert.asyncThrows(() => {
    return visit('/posts/1');
 }, 'GET /posts/1 returned a 500');

Atinux

const waitFor = (ms) => new Promise(r => setTimeout(r, ms))
const asyncForEach = async (array, callback) => {
  for (let index = 0; index < array.length; index++) {
    await callback(array[index], index, array)
  }
}

const start = async () => {
  await asyncForEach([1, 2, 3], async (num) => {
    await waitFor(50)

asselstine

# My Heroku git production remote is called 'production'
git remote -v

# Yields:
#
# origin	git@github.com:Loft47/loft.git (fetch)
# origin	git@github.com:Loft47/loft.git (push)
# production	https://git.heroku.com/loft47-prod.git (fetch)
# production	https://git.heroku.com/loft47-prod.git (push)
# staging	https://git.heroku.com/vey-staging.git (fetch)

wbotelhos

require 'sidekiq/api'

# 1. Clear retry set

Sidekiq::RetrySet.new.clear

# 2. Clear scheduled jobs 

Sidekiq::ScheduledSet.new.clear