Request params need to be passed as json along with content-type header in order for the Rails API to cast the types properly. The to_json converts the ruby hash to a json string and then the headers help Rails parse the request body.

put '/api/v1/crm/update_sync_settings', 
    params: request_param.to_json, 
    headers: {'Content-Type' => 'application/json'}

Object.send(:remove_const, :ExampleClass)

But what if you want to remove namespaced classes in Ruby. You can use the same method, but instead of Object use the parent module where your class is nested.

module App
  module ExampleClass
  end 
end 

Object.send(:remove_const, :App::ExampleClass) ### ❌ Does not work!!!!

App.send(:remove_const, :ExampleClass) # ✅ This works

Now before removing the const, you can check if the constant is defined or not.

if App.const_defined?(:ExampleClass)
  App.send(:remove_const, :ExampleClass)
end

Perfect! 🍄

A triangle has an exterior angle sum equal to 360

A square has an exterior angle sum equal to 360

A pentagon has an exterior angle sum equal to 360

Quadrilaterals have exterior angle sum equal to 360

There's a pattern.

All of the above shapes are polygons, and polygons could have n-sides or n-angles.

To find the sum of interior angles for these polygons, we just subtract the exterior angle sum from the interior

a + b + ... aN = N * 180 - 360 

where a, b .. N are interior angles. 
N is number of angles in the polygon.

Yes, upward. This line is represented by y = x .

Now, let's see a line going downward.

This is represented by y = -x

Do you see the difference between the equations representing lines going upward and downward? If yes, what is it?

Let me tell you.

The first equation representing the line going upward has a positive +x equation on the right-hand side.

The second equation representing the line going downward has a negative -x equation on the right-hand side.

Let's try to understand a little bit more about them

Whenever we write y = (something) times (x) , that something is the slope of the line. So we could rewrite y = x as

y = (1) times (x)

The slop of the equation here is 1 which indicates that when x increases by 1, our y value also increases by 1.

Similarly, for y = -x , we can rewrite as

y = (-1) times (x)

The slope of the equation is -1 which indicates that when x increases by 1, y decreases by 1.

These equations can be represented by some symbols through which we can talk and discuss more easily. So, we can say the above equations are represented by

y = (m) times (x)

Here, m is the slope of the equation which equals to +1 or -1 in our equations. So in short, we can say y = mx represents a line on the graph that might be going upward or downward depending on the value of m - the slope.

So next time you see an equation like this

y = -7x

You can say, oh the slope is -7 which means for every increase of x , y decreases by 7 times.

Or when you see an positive equation like this

y = 13x

You can say, the slope is +13 , and this means when x increases by 1, y also increases by 13 times that of x.

These lines we have discussed are very simple linear lines that go through the origin (0, 0) . Both the lines intercept y-axis at 0.

Why these equations are important to recognize and knowing how to plot them could reveal insightful data when applied to our real-life problems related to growth, budgeting and obviously other phenomena in the universe.

Next, we will talk about y intercepts.

class Shape 
  @count = 6

  def instance_method_x
    puts "No: '#{@count}'"
  end 

  class << self 
    def class_method_x
      puts "No: '#{@count}'"
    end 
  end 
end

They are not visible to instance methods

Shape.new.instance_method_x #=> No: ''

They are visible to class methods

Shape.class_method_x #=> No: '6'

You can expose class instance variable via attr_reader

class Shape
  @count = 6

  class << self 
    attr_reader :count 
  end 
end 

# With that, you can access 
$> Shape.count 
#=> 6

Other points:

• They can be replaced by @@ class variables.

• They can be confusing with ordinary instance variables. Without the punctuation @@ or @, it can be difficult to understand whether the variable is associated with class or instance.

Class variables are variables prefixed by @@ .

class Shape 
  @@no_of_shapes = 6

  def instance_method_x
    puts "No: #{@@no_of_shapes}"
  end 

  class << self 
    def class_method_x
      puts "No: #{@@no_of_shapes}"
    end 
  end 
end

They are visible to class methods.

Shape.class_method_x # => No: 6

They are visible to instance methods.

Shape.new.instance_method_x # => No: 6

They cannot be accessed by instance of class.

shape = Shape.new 
puts shape.no_of_shapes 
#=> class_var.rb:5:in `<main>': undefined method `no_of_shapes' for #<Shape:0x000000011e968498> (NoMethodError)

Rails.cache.clear

Convert 'ABCD' to {"A"=>0, "B"=>0, "C"=>0, "D"=>0}

1. Using inject

    'ABCD'.chars.inject({}) { |memo, v| memo[v] = 0; memo  }
   

2. Using Hash

    Hash['ABCD'.chars.map { |v| [v, 0] }]
   

When you include a module inside class.

• All the instance method from the module becomes instance method for the instances of that class.
• All singleton or class methods from the module are not accessible from either instance or class. We will discuss soon.

extend: makes instance methods from module as class methods

When you extend a module inside class

• All the instance method from the module becomes singleton method of that class.
• All the singleton method from the module becomes are not accessible from either instance of class. We will discuss.

Let learn by example.

What happens when we include module A containing both instance method and class method inside class Test

module A 

  def foo
    puts 'foo'
  end

  def self.bar 
    puts 'bar'
  end
end

class Test 
  include A 
end

Test.new.foo 
#=> foo
Test.foo  
#=> undefined method `foo' for Test:Class (NoMethodError)
Test.new.bar 
#=> undefined method `bar' for #<Test:0x000000012984f330> (NoMethodError)
Test.bar
#=> undefined method `bar' for Test:Class (NoMethodError)

What happens when we extend module A inside class Test

module A 

  def foo
    puts 'foo'
  end

  def self.bar 
    puts 'bar'
  end
end

class Test 
  extend A 
end

Test.new.foo 
#=> undefined method `foo' for #<Test:0x000000014a106eb8> (NoMethodError)
Test.foo  
#=> foo
Test.new.bar 
#=> undefined method `bar' for #<Test:0x000000014791b228> (NoMethodError)
Test.bar
#=> undefined method `bar' for Test:Class (NoMethodError)

What if we want to include a module having both instance and class level methods, and include both instance and class level methods. We can do it this way. Explanation after the example.

module A 

  def foo
    puts 'foo'
  end

  # Define all your singleton or class level methods here. Notice that we are not using `self` 
  # reference here.
  module ClassMethods
    def bar 
      puts 'bar'
    end
  end

  # This is a hook which will run when the module is included by another module. `base` is 
  # the class that included the module. Then we just `extend` all methods inside module 
  # `ClassMethods` so that those methods become singleton inside the base class.
  def self.included(base)
    base.extend ClassMethods
  end
end

class Test 
  include A 
end

Test.new.foo
#=> foo 
Test.bar
#=> bar
Test.new.bar
#=> undefined method `bar' for #<Test:0x0000000129186eb8> (NoMethodError)

The image is used by a container.

A container has a process and is being instantiated by container orchestrators.

Kubernetes, Mesos, Rkt, Docker Engine are all container orchestrator engines.

Kubernetes engine does a lot of things for distributed, large scale deployment with containers. It can be deployed by anyone anywhere. Why? because it's open-sourced. It requires virtual machines to set up its own infrastructure. A most common architecture is a single master server and two worker nodes.

Some of the vendors that provide Kubernetes service are:

• Google provides GKS.
• AWS provides EKS.
• Azure provides AKS.
• Digital Ocean Kubernetes

You and your company can have your own on-premise Kubernetes cluster and manage it by yourself.

3. Create a directory

with following files. Each step shows what's in those files.

├── docker-compose.yml
├── Dockerfile.Mongo.Local
├── db_init
 │   └── create_databases.sh

2. Create your local version of bitnami/mongodb image

# File name: Dockerfile.Mongo.Local
FROM bitnami/mongodb:4.0

USER root
RUN chmod 755 libmongodb.sh

3. Your docker compose yaml

version: "3"
services:
  mongo-db:
    # image: 'bitnami/mongodb:latest'
    build:
      context: .
      dockerfile: Dockerfile.Mongo.Local
    ports:
      - "27017:27017"
    volumes:
      - ./db_init:/docker-entrypoint-initdb.d
    environment:
      MONGODB_ROOT_PASSWORD: admin

4. Prepare bash script

for creating multiple databases

# create_databases.sh
/libmongodb.sh

mongodb_execute 'root' "$MONGODB_ROOT_PASSWORD" "" "127.0.0.1" <<EOF
  use schooldb
  db.getSiblingDB('schooldb').createCollection('students')
  use accountdb
  db.getSiblingDB('accountdb').createCollection('customer')
EOF

5. Start your docker

$ docker-compose up 
...
...
mongo-db_1       | MongoDB shell version v4.0.13
mongo-db_1       | connecting to: mongodb://127.0.0.1:27017/?gssapiServiceName=mongodb
mongo-db_1       | Implicit session: session { "id" : UUID("a7dc5873-e649-42dd-9b50-621521b57479") }
mongo-db_1       | MongoDB server version: 4.0.13
mongo-db_1       | switched to db schooldb
mongo-db_1       | { "ok" : 1 }
mongo-db_1       | switched to db accountdb
mongo-db_1       | { "ok" : 1 }
mongo-db_1       | bye

....

Local database

mongodump --db=test-db

Remote database

mongodump -u=USERNAME -p=PASSWORD --host=HOST_NAME/HOST_IP --port=HOST_PORT  --out {YOUR_DIRECTOTY_PATH} --db=DB_NAME

After dumping you will have a dump directory

➜ ~ tree dump
dump
└── test
    ├── cats.bson
    ├── cats.metadata.json
    ├── device.bson
    ├── device.metadata.json
    ├── event_data.bson
    ├── event_data.metadata.json
    ├── organisation.bson
    ├── organisation.metadata.json
    ├── organization.bson
    └── organization.metadata.json

2. Restore

This will restore everything to your local mongo instance

mongorestore  dump/

If you want to dump a specific collection, you can filter like below while restoring

mongorestore --nsInclude=test.cats dump/

Edit your /etc/nginx/sites-enabled/<your-app>

  location ~* {
    limit_except GET {
      allow 192.168.1.0/32;
      deny all;
    }
  }

Restart your server:

sudo service nginx restart

If the restart fails, then you might have made a syntax error in your nginx configuration. After a successful restart, you will start receiving 403 responses for all the requests except GET/HEAD.

<html>
    <head>
        <title>403 Forbidden</title>
    </head>
    <body bgcolor="white">
        <center>
            <h1>403 Forbidden</h1>
        </center>
        <hr>
        <center>nginx/1.14.0 (Ubuntu)</center>
    </body>
</html>

Keep in mind,limit_except is required to be declared inside a location directive.