DEV Community: Pin Loon Lee

Github action to automatically push to another repository

Pin Loon Lee — Sun, 18 Sep 2022 09:24:08 +0000

Github action to automatically push to another repository

Have you ever had the need for some of your repository to automatically push the content to another repository?

There may be couple of reason for this, perhaps your main repository is not yet shareable or you would like to keep some content out of the other repository, perhaps you wish to keep the main repository private while acting as a centralized repository to control contents that are private and partially public.

Since I have just started to write post in Medium recently, I had the need to do so when I wish to organize the posts in a better manner. To ease my life of writing post, I have been using Github action from Brian Mayo to automatically publish the post to Medium. All I have to do is just writting down the post using Markdown format and push to Github. The blog repository has always been publicly available as it is also acting as a storage space for the sample codes used in the post.

Nevertheless, when I realized there might be someday when some of the post may be only accessible by Medium members, I should keep the content private in a separate repository while enabling the codes used in the post to be publicly available. After considering git submodule, encrypted markdown, I have decided to keep current blog repository (that contains both post and code) private, while having an additional Github's action to export only the shared code to another public repository.

That is when I found Github action from Carles Pina Estany useful for the case.

To better illustrate, I have created mock-medium-source and mock-medium-output to mock my use case.

From the mock-medium-source, the file structure is as below

├── .github
│   ├── workflows
│   │   ├── medium-publish.yml
├── posts
│   ├── 001
│   │   ├── files
│   │   │   ├── Makefile
│   │   │   ├── mock.cpp
│   │   ├── post1.md
│   ├── 002
│   │   ├── files
│   │   │   ├── Makefile
│   │   ├── note.txt
│   │   ├── post2.md
├── README.md

The post in Medium would be originated from .md files while the rest of the content under posts/<number> would be reference code or information about the post.

Hence, the thing that I shall keep private would be the markdown file as the shared code would be less meaningful without the content of the post. Although Github Gist is a popular way to share code and snippets, at this moment I still prefer to keep code in a single place together with Makefile or CMakeLists.txt to ease compilation and running of code. I did not use any fancy operation to filter out those private content from mock-medium-source before pushing mock-medium-output, currently it is just a simple deleting of those markdown files before pushing to other repository.

The expected file structure of mock-medium-output repository would be just

├── posts
│   ├── 001
│   │   ├── files
│   │   │   ├── Makefile
│   │   │   ├── mock.cpp
│   ├── 002
│   │   ├── files
│   │   │   ├── Makefile
│   │   ├── note.txt

The yaml file for Github workflow in mock-medium-source is as below, (remember to create secrets for the SSH_DEPLOY_KEY)

name: Publish to Medium

"on":
  push:
    branches:
      - master
    paths:
      - 'posts/**'

jobs:
  post:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v2
      - name: Creates output folder and remove markdown
        run:  |
              mkdir output
              rm -rf posts/*/*.md
              cp -r posts output
      - name: Pushes to public repository
        id: push_directory
        uses: cpina/github-action-push-to-another-repository@ssh-deploy-key
        env:
          SSH_DEPLOY_KEY: ${{ secrets.WORKFLOW_DEPLOY_KEY }}
        with:
          source-directory: output/
          destination-github-username: 'pllee4-Experimental'
          destination-repository-name: 'mock-medium-output'
          user-email: pinloon_0428@hotmail.com
          commit-message: pushed from $GITHUB_REF
          target-branch: master

For this yaml files, there are two things to be noted down

The public repo mock-medium-output must be created before it is able to be pushed from mock-medium-source ("created" means it is pushed with at least one commit in order to have a valid branch as target branch for the source repository)
From the Github workflows, the path is posts/**, that means the running of the workflows of mock-medium-source would only be triggered when there is changes on the directory under posts. This makes sense for my usage, however you could remove this part if you wish to.

That is it! I can continue writing post using markdown format and have the workflows automatically push the relevant public content to be shared with you!

Thanks and hope this is helpful for you!

Perfect forwarding

Pin Loon Lee — Sat, 13 Aug 2022 00:00:00 +0000

Perfect forwarding

What is meant by perfect forwarding?

"Forwarding" is the process where one function forwards its parameter to another function.
When it is perfect, the function should receive the same object passed from the function that does the forwarding.

In other words, perfect forwarding means we do not just forward objects, we also forward their salient properties, whether they are lvalues or rvalues, const or volatile.

Do not worry too much about the definition, we will go through some simple examples.

Let say we have a simple class as below

class Object {
 public:
  Object() = default;

  void SetName(const std::string &name) { name_ = std::move(name); }
  std::string GetName() const { return name_; }

 private:
  std::string name_;
};

We have also few overloaded functions named UseObject

void UseObject(Object &) {
  std::cout << "calling UseObject(Object &)" << std::endl;
}

void UseObject(const Object &) {
  std::cout << "calling UseObject(const Object &)" << std::endl;
}

void UseObject(Object &&) {
  std::cout << "calling UseObject(Object &&)" << std::endl;
}

Now we have the main

int main() {
  Object object;
  const Object const_object;
  UseObject(object);
  UseObject(const_object);
  UseObject(std::move(object));
}

which would produce the output as below

calling UseObject(Object &)
calling UseObject(const Object &)
calling UseObject(Object &&)

Right now, let say we have a simple template function that tries to pass the argument to UseObject function

template <typename T>
void NotForwardToUseObject(T x) {
  UseObject(x);
}

Now, running of code

int main() {
  Object object;
  const Object const_object;
  NotForwardToUseObject(object);
  NotForwardToUseObject(const_object);
  NotForwardToUseObject(std::move(object));
}

would result in

calling UseObject(Object &)
calling UseObject(Object &)
calling UseObject(Object &)

where functions are not called accordingly as what we have expected earlier.

This is due to the const and rvalueness being ignored by the template deduction for void NotForwardToUseObject(T x) .

To deal with reference parameters, we have to use universal references, because only universal reference parameters encode information about the lvalueness and rvalueness of the arguments that are passed to them.

Now if we use universal reference for template argument,

template <typename T>
void HalfForwardToUseObject(T &&x) {  // universal reference
  UseObject(x);
}

Running of code

int main() {
  Object object;
  const Object const_object;
  HalfForwardToUseObject(object);
  HalfForwardToUseObject(const_object);
  HalfForwardToUseObject(std::move(object));
}

would result in

calling UseObject(Object &)
calling UseObject(const Object &)
calling UseObject(Object &)

Almost! Forwarding of const seems working but rvalueness of the argument still not getting forwarded correctly.

To have a true perfect forwarding, we have to cast x to its original type and lvalue- or r-value-ness

template <typename T>
void ForwardToUseObject(T &&x) {
  UseObject(static_cast<T &&>(x));
}

Now, running of code

int main() {
  Object object;
  const Object const_object;
  ForwardToUseObject(object);
  ForwardToUseObject(const_object);
  ForwardToUseObject(std::move(object));
}

would result in

calling UseObject(Object &)
calling UseObject(const Object &)
calling UseObject(Object &&)

Perfect! We have successfully passed the object properly.
To simplify the code, we can use std::forward from C++ <utility> library,

template <typename T>
void PerfectForwardToUseObject(T &&x) {
  UseObject(std::forward<T>(x));
}

I hope with the examples above, now you have understand what is meant by perfect forwarding.
As usual, the code above is accessible from my github

Thanks for reading till the end of the post!

Hello world!

Pin Loon Lee — Fri, 10 Jun 2022 04:25:22 +0000

Hello world!

Hello world! I believe this is what a normal beginner for programming would see as they first try to code in certain programming language.

As this is also my very first post in Dev, I would like to say Hello world! too!

As a C/C++ programmer, a simple program as below:

#include <iostream>

int main(int argc, char **argv) { 
  std::cout << "Hello world!" << std::endl; 
  return 0;
}

would provide the output of

Hello world!

Nevertheless, it would be boring if we only able to produce the output by using the sample above especially in the world of C/C++ where we should know everything in detail underlying the code.

To do that, we will compile the code in a bare metal version using inline assembly language.

Inline assembly language

One of the way is to have helloworld.c as below

int main(void) {
  register int    syscall_no  asm("rax") = 1;
  register int    arg1        asm("rdi") = 1;
  register char*  arg2        asm("rsi") = "Hello world!\n";
  register int    arg3        asm("rdx") = 13;
  asm("syscall");
  return 0;
}

The system call number is put in register rax
The rest of the arguments are put in registers rdi, rsi and rdx
%rdi, %rsi, %rdx, %rcx, %r8, and %r9 are used to pass the first six integer or pointer parameters to called functions

In other words, the code above is executing the system call of

write(STDOUT_FILENO,
   "Hello world!\n",
   sizeof("Hello world!\n")
);

Running of code under Linux x86-x64

$ gcc -o helloworld helloworld.c
$ ./helloworld

Program without main

To make more fun, we are going to write code that does not have main, let's call it nomain program

The entry point for the program would be

void nomain() {
  print();
  exit();
}

where the print and exit functions would be

void print() {
  register char* arg2 asm("rsi") = "Hello world!\n";
  asm("mov $1,%%rax \n\t"
      "mov $1,%%rdi \n\t"
      "mov $13,%%rdx \n\t"
      "syscall \n\t" ::
          : "rdi", "rdx");
}

void exit() {
  asm("mov $0,%rdi \n\t"
      "mov $60,%rax \n\t"
      "syscall \n\t");
}

The print function is similar as the example described just now. For the exit() function, it is executing system call of

exit(EXIT_SUCCESS);

with return code 0, while 60 is system call number for exit

To check the return code, we can type

$ echo $?

after executing the executable.

Running of nomain code under Linux x86-x64

$ gcc -c -fno-builtin helloworld.c
$ ld -static -e nomain -o helloworld helloworld.o
$ ./helloworld

GCC has provided a lot of built-in functions, normally it would replace C function with internal function of compiler for optimization purposes. For example, if only strings are involved in the printf function, it would be replaced with puts function to save time for formatting interpretation. exit() function is one of the internal function for GCC, hence we have to put no-builtin flag to disable the built-in functions
The entry point is then configured through -e nomain

Thanks for reading my very first post, hope you enjoy the reading!