Mazhar's Blog

Join Seedr

Fri, 12 May 2023 05:45:52 +0000

Seedr.cc is a cloud-based service that allows users to download and stream torrent files. It provides a convenient and secure way to access torrent content without the need for a traditional torrent client on your device. Here are some key points about Seedr.cc:

Account Creation: To use Seedr.cc, you need to create an account. You can create an account using your Google account or by signing up directly on the Seedr.cc website.
Storage and Tasks: With a free account, you initially get 2GB of storage, which can be increased by completing simple tasks provided on the website. These tasks likely involve activities such as referring friends, sharing content, or participating in promotional offers.
Premium Membership: Seedr.cc offers premium memberships with various options. These memberships provide additional storage space, faster download speeds, and other enhanced features. The specific details of premium memberships, such as pricing and benefits, can be found on the Seedr.cc website.
Downloading Torrents: Once you have created an account, you can either copy the torrent link or upload the torrent file to your Seedr.cc account. Seedr.cc will then download the torrent file to their servers, and you will be provided with a direct link to download the file to your device.
Streaming and Accessibility: Seedr.cc uses streaming technology that allows you to directly access and stream videos, music, and other content from your torrent collection. This can be done on any device with an internet connection, without the need to download the entire file.
Privacy and Security: Seedr.cc offers high-level transport encryption to ensure the privacy and security of your data. They claim to protect against malware, viruses, and external tracking, providing a secure environment for accessing and downloading torrent content.
Speed and Efficiency: Seedr.cc boasts fast download speeds due to their high-speed infrastructure. Torrents are typically downloaded to the cloud within a few minutes or even seconds, allowing for quick access to the content you desire.

It’s always a good practice to visit the official Seedr.cc website to get the most up-to-date and accurate information about their services, features, and terms of use.

Join now: Website URL: https://www.seedr.cc/

Use Gearman Job Server in PHP

Thu, 28 Mar 2019 00:00:00 +0000

Gearman is a Job Server which has many language interfaces. If you are familiar with Python Celery then you will understand at a glance. Unlike Celery, Gearman is a task runner. The only difference is in Gearman, you have to program your worker too. I love Gearman because not only tasks but also the worker can be written with any suitable language. Also the core of Gearman is built with C/C++, that’s why it is very very fast. Say, you are working with PHP and you need a background task runner, go for Gearman. Don’t worry, many big companies are using it like Craig’s List, Tumblr, Yelp, Etsy etc.

Now, let’s create a Background Task Runner for our PHP Application. To do that we need to install gearman server on our PC / Server first. If we are using Ubuntu then it is very easy like sudo apt install gearman-job-server and there are tons of article how to install gearman. Feel free to install it first. Then we have to install the PHP PECL extension for gearman. In Ubuntu we can simply run sudo pecl install gearman. Again, there are tons of articles on how to install gearman libraries on your PHP. When you have done with the installations, let’s jump directly into coding. Don’t forget to run the gearman job server.

First lets make the worker. Make a new file named gearman-worker.php with:

$worker = new GearmanWorker();
$worker->addServer(); // additional server address can be passed here

$worker->addFunction(
    "ping",
    function (GearmanJob $job) {
        print "received: {$job->handle()}\n";
        
        for ($x = 1; $x < 6; $x++) {
            print "sending data: ping {$x}\n";
            
            $job->sendData("ping {$x}");
            sleep(1);
        }
        
        print "waiting\n";
    }
);

// your other function defination goes here or you may call other files / modules etc

print "waiting\n";

while ($worker->work());

That’s our simple worker with a function named ping. You can add your other functions too. Now let’s make a client and call that function we just created. Make a file named gearman-client.php with following content:

$client = new GearmanClient();
$client->addServer();

$client->setDataCallback(
    function (GearmanTask $task) {
        print "data: {$task->data()}\n";
    }
);

print "sending\n";

$client->addTask("ping", "hello");
// you can also call tasks async using $client->doBackground()
$client->runTasks();

Now we have to keep the worker running. Simply just keep the worker running in our terminal like php gearman-worker.php and then run the client from another terminal like php gearman-client.php.

If we look at the client terminal its output is like:

sending
data: ping 1
data: ping 2
data: ping 3
data: ping 4
data: ping 5

And the worker terminal will output like:

waiting
received: H:[network id]:[task id]
sending data: ping 1
sending data: ping 2
sending data: ping 3
sending data: ping 4
sending data: ping 5
waiting

Note: You have to keep the worker running.

This is a simple way of making own worker using Gearman. There are plenty of ways we can use gearman and that’s the fun of using it. Hope you guys like it.

Thanks a lot.

Generate REST API from DB Schema in Crystal

Sat, 23 Feb 2019 00:00:00 +0000

I had a MySQL schema from a booking.com like platform. I wanted to generate REST API very fast from my MySQL database tables. Like I have a table named hotels. I want to generate following endpoints:

GET    /api/hotels
GET    /api/hotels/:id
POST   /api/hotels
PUT    /api/hotels/:id
DELETE /api/hotels/:id

I tried to use Haskell but the security was very low on postgrest package in Haskell. The postgrest is amazing, it generates the api endpoints from a database. But the problem is it will delete all the rows in a table if I perform a DELETE request in /api/hotels. So, I can not use it.

Finally found that Kemal Rest API is the perfect for doing this which is on Crystal Lang. Suppose I have a table named hotels. This is what I did. I installed Crystal Lang. I ran shards init app hotel to generate an empty project. shards is the dependency manager, task runner for crystal. So after this I have a folder named hotel which has the following structure:

.
├── LICENSE
├── README.md
├── db.sql
├── shard.lock
├── shard.yml
├── spec
│   ├── hotel_spec.cr
│   └── spec_helper.cr
└── src
    └── hotel.cr

I have modified the shard.yml file and added following lines at the end.

dependencies:
  db:
    github: crystal-lang/crystal-db
  kemal:
    github: kemalcr/kemal
  kemal-rest-api:
    github: blocknotes/kemal-rest-api
  mysql:
    github: crystal-lang/crystal-mysql

I have ran the shards install to install the libraries and modified the hotel.cr file like following:

require "db"
require "mysql"
require "kemal"
require "kemal-rest-api"
require "json"

DB_NAME       = "hotel"
DB_CONNECTION = "mysql://hotel@localhost/#{DB_NAME}"

class MyModel < KemalRestApi::Adapters::CrystalDbModel
  def initialize
    super DB_CONNECTION, "hotels"
  end
end

module WebApp
  res = KemalRestApi::Resource.new MyModel.new, KemalRestApi::ALL_ACTIONS, prefix: "api", singular: "hotel"

  # Routes
  get "/" do |env|
    env.response.content_type = "application/json"
    {name: "--", info: "--", version: "0.0.1"}.to_json
  end

  res.generate_routes!

  # Starts Kemal
  Kemal.run
end

to generate these routes automatically:

GET    /api/hotels
GET    /api/hotels/:id
POST   /api/hotels
PUT    /api/hotels/:id
DELETE /api/hotels/:id

At last I have ran shards build to make the binary executable file. And ran it like ./bin/hotel. And the API is working properly.

The Crystal code is just like Ruby language but as fast as C. What I need to do next is make an array of tables and it will generate the API endpoints. I don’t need to take hassle about images and users because we already have other microservices to handle those. Also, this API will never be exposed to clients rather another API wrapper will fetch data from it. So, I found it perfect fit for my job.

Thus I have made my hotel API up in just couple of hours.

Your First Web Application with Spock

Fri, 11 Jan 2019 00:00:00 +0000

The Spock web framework for Haskell gives you a light but complete foundation to build web servers on, be it for traditional server-side rendered applications, or APIs for single-page applications. Compared to the Scotty framework, Spock is slightly richer in its feature set, and is more opinionated regarding the application architecture. In this episode we explore the basics of Spock and in-memory server state, as we build a note keeper application.

Show Notes

We are starting with an empty project called notekeeper, and a Cabal file specifying an executable. To get started, we add dependencies for Spock, http-types, text, and mtl.

name:                notekeeper
version:             0.1.0.0
category:            Web
build-type:          Simple
cabal-version:       >=1.10

executable notekeeper
  main-is:            Main.hs
  build-depends:      base >=4.10 && <4.11
                    , Spock
                    , http-types
                    , text
                    , mtl
  hs-source-dirs:     src
  default-language:   Haskell2010

In Main.hs, we start out by importing the Web.Spock and Web.Spock.Config modules. Those are all we need to get a basic server running.

module Main where

import Web.Spock
import Web.Spock.Config

The function we need in our definition of main is runSpock, which has the type:

runSpock :: Port -> IO Middleware -> IO ()

We run our server on port 8080, with the middleware returned by a function called spock. It takes a configuration, and our application. We’ll leave those as typed holes for now, and see what we need.

main :: IO ()
main = do
  runSpock 8080 (spock _cfg _app)

The _app hole tells us we need some value of type SpockM conn0 sess0 st0 (), which is the Spock monad for defining an application. It also tells us that the type variables used as parameters are ambiguous.

Found hole: _app :: SpockM conn0 sess0 st0 ()
Where: ‘conn0’ is an ambiguous type variable
       ‘sess0’ is an ambiguous type variable
       ‘st0’ is an ambiguous type variable

The _cfg hole tells us that we need a value of type SpockCfg conn0 sess0 st0, and that the same type variables as we saw before are ambiguous. There is a connection between the type parameters of SpockM and SpockCfg.

Found hole: _cfg :: SpockCfg conn0 sess0 st0
Where: ‘conn0’ is an ambiguous type variable
       ‘sess0’ is an ambiguous type variable
       ‘st0’ is an ambiguous type variable

We begin by defining app locally, not doing any routing, only returning ().

main :: IO ()
main = do
  let app = return ()
  runSpock 8080 (spock _cfg app)

This would work, but the type variables are still ambiguous for the configuration. If we move the definition of app to the top-level, and give it an explicit type signature, we can pin down those type arguments.

The type SpockM is parameterized by four types:

the database connection type (conn)
the session type (sess)
the state type (st)
the monadic return value’s type

Initially, we won’t have any database, sessions, or state, so we use the () type for all of them.

app :: SpockM () () () ()
app = return ()

Now that we’ve specified which types we are using in our application, the typed hole _cfg has no ambiguous variables. To construct a configuration value, we use the defaultSpockCfg, taking a session configuration, a pool or connection for a database, and an initial state. The database parameter cannot be a () value, and we’ll leave it as a typed hole to illustrate why.

Found hole: _db :: PoolOrConn ()

PoolOrConn is parameterized by (), and there is only one value with that type: the PCNoDatabase constructor defined by Spock. Using that, we obtain a configuration for our Spock application, and we have a rather useless, but working web server.

main :: IO ()
main = do
  cfg <- defaultSpockCfg () PCNoDatabase ()
  runSpock 8080 (spock cfg app)

To run the web server, and have it reload on source code changes, we can use the excellent ghcid tool. By default, it only reloads your code and prints any type errors, but if we override the test command using -T, we can have it run the main function when the code successfully compiles.

$ ghcid -T :main
Running test...

Spock is running on port 8080

In our web browser, we can see that we get a “404 Not Found” when requesting http://localhost:8080. We’ll keep ghcid running in the background.

Defining Routes

Before we begin defining routes, we’ll create a type alias for our application type to factor out the SpockM details. Server takes a single type argument a, the monadic return value type. We use it as the type of our app definition.

type Server a = SpockM () () () a

app :: Server ()
app = return ()

We define a route for GET requests to the root path, responding with a text greeting.

app :: Server ()
app = get root (text "Hello!")

Now we get a type error, explaining that we can’t pass a regular String to the text function. We enable OverloadedStrings to construct a Text value instead.

{-# LANGUAGE OverloadedStrings #-}

Reloading the web browser, we see our greeting “Hello!” displayed.

Rendering HTML

Responding with plain text in a web application is a little dull. Instead, we’ll respond with HTML using the html function, and some lovingly hand-crafted markup.

app :: Server ()
app = get root (html "<h1>Hello!</h1>")

Now get a proper heading, at least.

Constructing HTML markup in strings is not great, though. Instead, we’ll use Lucid, an embedded DSL for HTML markup. In our Cabal file, we add the dependency lucid, along with Spock-lucid, a small library integrating Spock and Lucid.

executable notekeeper
  main-is:            Main.hs
  build-depends:      base >=4.10 && <4.11
                    , Spock
                    , http-types
                    , text
                    , mtl
                    , lucid
                    , Spock-lucid
  hs-source-dirs:     src
  default-language:   Haskell2010

Back in Main.hs, we import the lucid function from Web.Spock.Lucid, along with the entire Lucid module.

import Web.Spock.Lucid (lucid)
import Lucid

Now we can use lucid instead of html, and the Lucid DSL to construct our markup. Using do notation, we can define sibling elements, which in our case will be a heading and a paragraph.

app :: Server ()
app = get root $ lucid $ do
  h1_ "Hello!"
  p_ "How are you today?"

Reloading the web browser, we see the two elements rendered.

Keeping Notes with Server State

We are ready to implement the note keeping functionality of our application. Instead of using a server state of type (), we’ll define and use the ServerState and Note data types.

The server state consists of an IORef holding a list of Note values. An IORef is a variable that can be mutated atomically in the IO monad.

newtype ServerState = ServerState { notes :: IORef [Note] }

A note has an author, and contents, both of type Text.

data Note = Note { author :: Text, contents :: Text }

To use Text and IORef we need to import them.

import Data.Text (Text)
import Data.IORef

Finally, we change the Server type alias to use ServerState.

type Server a = SpockM () () ServerState a

Navigating to the next type error we get, we see that we cannot use an application requiring a state of type ServerState with a configuration with state of type ().

Couldn't match type ‘ServerState’ with ‘()’
      Expected type: SpockM () () () ()
      Actual type: Server ()

We construct a ServerState by mapping the constructor over a newIORef action, with an empty list of notes, and use it in our configuration.

main :: IO ()
main = do
  st <- ServerState <$> newIORef []
  cfg <- defaultSpockCfg () PCNoDatabase st
  runSpock 8080 (spock cfg app)

It compiles again! To have something that we can render, we add two notes to the initial state.

main :: IO ()
main = do
  st <- ServerState <$>
    newIORef [ Note "Alice" "Must not forget to walk the dog."
             , Note "Bob" "Must. Eat. Pizza!"
             ]
  cfg <- defaultSpockCfg () PCNoDatabase st
  runSpock 8080 (spock cfg app)

Now we have something to render, so we change the greeting markup to instead list the notes in our state. We’ll use an unordered list, constructed using ul_, and for each note render a list item, containing the note author and contents.

app :: Server ()
app = get root $ lucid $ do
  h1_ "Notes"
  ul_ $ forM_ notes' $ \note -> li_ $ do
    toHtml (author note)
    ": "
    toHtml (contents note)

The forM_ function is not in scope, so we need to import it.

import Control.Monad (forM_)

Also, we don’t have a list of notes available. We need to read it from the IORef in our server state. The getState action in Spock returns our server state, from which we can extract and read the IORef.

app :: Server ()
app = get root $ do
  notes' <- getState >>= (liftIO . readIORef . notes)
  lucid $ do
    h1_ "Notes"
    ul_ $ forM_ notes' $ \note -> li_ $ do
      toHtml (author note)
      ": "
      toHtml (contents note)

The usage of getState might remind you of ask from the Reader monad.

The readIORef action has to be lifted into the ActionCtxt, which is the monadic type for Spock routes. Thus, we import and use liftIO.

import Control.Monad.IO.Class (liftIO)

No more errors, so we refresh the web browser and see our list of notes rendered.

How to call a C function in Golang

Wed, 26 Dec 2018 00:00:00 +0000

I’m writting this article after a very long time. This happens due to the work pressure in my daily life. There is not enough free time to write any article, even customize my own sites / portfolios.

Okay, today I will be showing you guys how to call native C (you can call C++ methods too) functions using Golang. To accomplish this, I would think that you guys have this things installed on your system:

go
gcc
pkg-config

Let’s create a project in your $GOPATH/src. I have created my project in $GOPATH/src/github.com/mazhar266/goc. There I’ve added a file named square.c with the following function:

int square(int a)
{
  return a * a;
}

Now we will call this function from our go program. Let’s create a blank main.go file. Let’s just start writting the basic structure like:

package main

import "fmt"

func main() {
  ...
}

Now include the C package and include our square.c file which contains our square function. Add this line after package declaration:

//#include<square.c>
import "C"

This first line imports our C program (the square.c file, you will understand if you are a C programmer). The second line imports the basic functionality in Go to talk with C.

Now make a method / function which will call the C function and return the result. This is for making the main method clean.

func makeSquare(a int) int {
  //Convert Go ints to C ints
  aC := C.int(a)

  sum, err := C.square(aC)
  if err != nil {
    return 0
  }

  //Convert C.int result to Go int
  res := int(sum)

  return res
}

You can easily understand what this method does. It converts integer argument a for Go to integer argument for C. And also converts the returned result from C integer to Go integer.

So, we can call the function from the main function like:

func main() {
  fmt.Print(makeSquare(9))
}

Now if we run go run main.go we will see the output 81 in the console.

That’s the basic of calling a C function from Golang. For dealing with complex C programs which uses thirdparty libraries, your have to maintain CFLAGS and LDFLAGS from your go application. We will see that in another article.

You can find the sample source code here https://github.com/mazhar266/goc

Welcome to Jekyll!

Thu, 09 Feb 2017 07:35:52 +0000

You’ll find this post in your _posts directory. Go ahead and edit it and re-build the site to see your changes. You can rebuild the site in many different ways, but the most common way is to run jekyll serve, which launches a web server and auto-regenerates your site when a file is updated.

To add new posts, simply add a file in the _posts directory that follows the convention YYYY-MM-DD-name-of-post.ext and includes the necessary front matter. Take a look at the source for this post to get an idea about how it works.

Jekyll also offers powerful support for code snippets:

def print_hi(name)
  puts "Hi, #{name}"
end
print_hi('Tom')
#=> prints 'Hi, Tom' to STDOUT.

Check out the Jekyll docs for more info on how to get the most out of Jekyll. File all bugs/feature requests at Jekyll’s GitHub repo. If you have questions, you can ask them on Jekyll Talk.

Reset MySQL Root Password on Ubuntu

Sun, 28 Feb 2016 12:58:48 +0000

First please ensure that you really forgot the root password.

mysql -u root -p

If you really forgot the password then resetting the password is needed. Use dpkg-reconfigure to reconfigure the root user.

####Check the MySQL version First of all check the MySQL server version like this:

apt-cache policy mysql-server

the above command gave me output like:

Installed: 5.5.37-0ubuntu0.12.04.1

####Start reconfiguring the MySQL Start using the following shell command:

sudo dpkg-reconfigure mysql-server-*.*

Please, put your MySQL version name instead of mysql-server-. . For me I have used mysql-server-5.5 . It will stop the database and promt for reconfiguration.

You can now enter your new password for the root user and so on. After the reconfiguration is completed the MySQL server will be automatically started.

Now you can login using your new password like this:

mysql -u root -p

That’s all for now. Thank you.

How to setup a Cron job in Ubuntu

Thu, 18 Feb 2016 02:52:20 +0000

Most of my friends ask me how to setup a cron job in Ubuntu. They often face this situation when they have to setup a cron job for their application. I myself also work with the cron job feature according to my application’s demand. Here is how to setup a cron job in Ubuntu in less than a minute.

You can put a shell script in one of these folders: /etc/cron.daily, /etc/cron.hourly, /etc/cron.monthly or /etc/cron.weekly. This should run your script according to the folder name. Such as the scripts in cron.daily folder will be run on daily basis.

If these are not enough for you then you can define your own using the crontab.

$ crontab -e

This will open personal crontab (cron configuration file) for you. Every lines are tasks that will be run according to the configuration written on that line. The lines are written in this format:

minute hour day-of-month month day-of-week command

For every number you can define a list by separating the numbers using a comma (,) . You can also use intervals like */20 which will run every 20th. If we put */20 at the minutes field then it will be equivalent to 0,20,40.

Suppose:

* 0 * * * path/to/command
*/15 * * * * path/to/command2

The first command will be run once a day when the time is 0 that means 12am. The second command will be run on every 15 minutes interval.

That’s all guys, that’s how to setup a cron job in Ubuntu. Thank you.

Change the Bootstrap NavBar Breakpoint

Thu, 29 Oct 2015 02:36:05 +0000

I use mostly Bootstrap framework for my every projects. Although I like the Foundation framework. If the provided design does not seem proper for any of these framework I used to hard code the rest of the work. I often face a situation like designer wants a different breakpoint to trigger the mobile menu. Suppose a designer wants the mobile menu from the “md” size. This is quite easy in bootstrap. There are two ways of doing this. One is to modify the less source file and recompile it. The second one is directly write CSS codes.

###Modifying the LESS file Change the @navbarCollapseWidth variable in less/variables.less file to your desired value. Then recompile the less file to produce the updated CSS file.

###Modifying the CSS file This is quite easy and I thing most of the people will use this method. Just Place this section in your stylesheet to overwrite the default behaviour.

/* showing the mobile menu */
@media (max-width: 1070px) {
    .navbar-header {
        float: none;
    }
    .navbar-toggle {
        display: block;
    }
    .navbar-collapse {
        border-top: 1px solid transparent;
        box-shadow: inset 0 1px 0 rgba(255,255,255,0.1);
    }
    .navbar-collapse.collapse {
        display: none!important;
    }
    .navbar-nav {
        float: none!important;
        margin: 7.5px -15px;
    }
    .navbar-nav>li {
        float: none;
    }
    .navbar-nav>li>a {
        padding-top: 10px;
        padding-bottom: 10px;
    }
}

Note: Replace 1070px to your desired value.

That’s it, that’s how to change the default Bootstrap NavBar breakpoint.

How to Install JAVA 8 on CentOS, RHEL and Fedora

Sun, 09 Aug 2015 02:30:21 +0000

Recently I was instructed to install Java 8 on our servers. There are plenty of reasons for doing that. Here’s how I have done that. Of-course you will need root access to your server. If your are using a shared hosting, then it will be wise to leave this thing to your hosting authority.

###Download the Java 8 Lets keep the java source to our /opt/ directory.

####For 64 Bit Servers

# cd /opt/
# wget --no-cookies --no-check-certificate --header "Cookie: gpw_e24=http%3A%2F%2Fwww.oracle.com%2F; oraclelicense=accept-securebackup-cookie" "http://download.oracle.com/otn-pub/java/jdk/8u40-b25/jdk-8u40-linux-x64.tar.gz"

# tar xzf jdk-8u40-linux-x64.tar.gz

####For 32Bit Servers

# cd /opt/
# wget --no-cookies --no-check-certificate --header "Cookie: gpw_e24=http%3A%2F%2Fwww.oracle.com%2F; oraclelicense=accept-securebackup-cookie" "http://download.oracle.com/otn-pub/java/jdk/8u40-b25/jdk-8u40-linux-i586.tar.gz"

# tar xzf jdk-8u40-linux-i586.tar.gz

###Install Java 8 Now install it from the jdk1.8.0_40 directory.

# cd /opt/jdk1.8.0_40/
# alternatives --install /usr/bin/java java /opt/jdk1.8.0_40/bin/java 2
# alternatives --config java


There are 3 programs which provide 'java'.

  Selection    Command
-----------------------------------------------
*  1           /opt/jdk1.8.0/bin/java
 + 2           /opt/jdk1.8.0_25/bin/java
   3           /opt/jdk1.8.0_40/bin/java

Enter to keep the current selection[+], or type selection number: 3

Now install rest of the utilities.

# alternatives --install /usr/bin/jar jar /opt/jdk1.8.0_40/bin/jar 2
# alternatives --install /usr/bin/javac javac /opt/jdk1.8.0_40/bin/javac 2
# alternatives --set jar /opt/jdk1.8.0_40/bin/jar
# alternatives --set javac /opt/jdk1.8.0_40/bin/javac 

At this moment we have installed Java 8. So lets verify it if it’s working properly.

root@tecadmin ~# java -version

java version "1.8.0_40"
Java(TM) SE Runtime Environment (build 1.8.0_40-b25)
Java HotSpot(TM) 64-Bit Server VM (build 25.40-b25, mixed mode)

###Setup system variables Setup JAVA_HOME Variable

# export JAVA_HOME=/opt/jdk1.8.0_40

Setup JRE_HOME Variable

# export JRE_HOME=/opt/jdk1.8.0_40/jre

Setup PATH Variable

# export PATH=$PATH:/opt/jdk1.8.0_40/bin:/opt/jdk1.8.0_40/jre/bin

That’s the end. Now Java 8 is installed on your server.